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         QStringList list = QString(event->mimeData()->data("kdenlive/clip")).split(";");
 936         m_selectionGroup = new AbstractGroupItem(m_document->fps());
 937         QPoint pos = QPoint();
 938         DocClipBase *clip = m_document->getBaseClip(list.at(0));
 939         if (clip == NULL) kDebug() << " WARNING))))))))) CLIP NOT FOUND : " << list.at(0);
 940         ItemInfo info;
 941         info.startPos = GenTime(0, m_document->fps());
 942         info.cropStart = GenTime(list.at(1).toInt(), m_document->fps());
 943         info.endPos = info.startPos + GenTime(list.at(2).toInt() - list.at(1).toInt(), m_document->fps());
 944         info.track = (int)(1 / m_tracksHeight);
 945         ClipItem *item = new ClipItem(clip, info, m_document->fps(), 1.0);
 946         m_selectionGroup->addToGroup(item);
 947         item->setFlags(QGraphicsItem::ItemIsSelectable);
 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         GenTime start = GenTime();
 960         for (int i = 0; i < ids.size(); ++i) {
 961             DocClipBase *clip = m_document->getBaseClip(ids.at(i));
 962             if (clip == NULL) kDebug() << " WARNING))))))))) CLIP NOT FOUND : " << ids.at(i);
 963             ItemInfo info;
 964             info.startPos = start;
 965             info.endPos = info.startPos + clip->duration();
 966             info.track = (int)(1 / m_tracksHeight);
 967             ClipItem *item = new ClipItem(clip, info, m_document->fps(), 1.0);
 968             start += clip->duration();
 969             m_selectionGroup->addToGroup(item);
 970             item->setFlags(QGraphicsItem::ItemIsSelectable);
 971         }
 972         //TODO: check if we do not overlap another clip when first dropping in timeline
 973         //if (insertPossible(m_selectionGroup, event->pos()))
 974         scene()->addItem(m_selectionGroup);
 975         event->acceptProposedAction();
 976     } else QGraphicsView::dragEnterEvent(event);
 977 }
 978
 979
 980 bool CustomTrackView::insertPossible(AbstractGroupItem *group, const QPoint &pos) const {
 981     QPolygonF path;
 982     QList<QGraphicsItem *> children = group->childItems();
 983     for (int i = 0; i < children.count(); i++) {
 984         if (children.at(i)->type() == AVWIDGET) {
 985             ClipItem *clip = static_cast <ClipItem *>(children.at(i));
 986             ItemInfo info = clip->info();
 987             kDebug() << " / / INSERT : " << pos.x();
 988             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);
 989             kDebug() << " / / INSERT RECT: " << shape;
 990             path = path.united(QPolygonF(shape));
 991         }
 992     }
 993
 994     QList<QGraphicsItem*> collindingItems = scene()->items(path, Qt::IntersectsItemShape);
 995     if (collindingItems.isEmpty()) return true;
 996     else {
 997         for (int i = 0; i < collindingItems.count(); i++) {
 998             QGraphicsItem *collision = collindingItems.at(i);
 999             if (collision->type() == AVWIDGET) {
1000                 // Collision
1001                 kDebug() << "// COLLISIION DETECTED";
1002                 return false;
1003             }
1004         }
1005         return true;
1006     }
1007
1008 }
1009
1010 void CustomTrackView::slotRefreshEffects(ClipItem *clip) {
1011     int track = m_document->tracksCount() - clip->track();
1012     GenTime pos = clip->startPos();
1013     if (!m_document->renderer()->mltRemoveEffect(track, pos, "-1", false, false)) {
1014         emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
1015         return;
1016     }
1017     bool success = true;
1018     for (int i = 0; i < clip->effectsCount(); i++) {
1019         if (!m_document->renderer()->mltAddEffect(track, pos, clip->getEffectArgs(clip->effectAt(i)), false)) success = false;
1020     }
1021     if (!success) emit displayMessage(i18n("Problem adding effect to clip"), ErrorMessage);
1022     m_document->renderer()->doRefresh();
1023 }
1024
1025 void CustomTrackView::addEffect(int track, GenTime pos, QDomElement effect) {
1026     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1027     if (clip) {
1028         if (!m_document->renderer()->mltAddEffect(track, pos, clip->addEffect(effect)))
1029             emit displayMessage(i18n("Problem adding effect to clip"), ErrorMessage);
1030         emit clipItemSelected(clip);
1031     } else emit displayMessage(i18n("Cannot find clip to add effect"), ErrorMessage);
1032 }
1033
1034 void CustomTrackView::deleteEffect(int track, GenTime pos, QDomElement effect) {
1035     QString index = effect.attribute("kdenlive_ix");
1036     if (!m_document->renderer()->mltRemoveEffect(track, pos, index, true) && effect.attribute("disabled") != "1") {
1037         kDebug() << "// ERROR REMOV EFFECT: " << index << ", DISABLE: " << effect.attribute("disabled");
1038         emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
1039         return;
1040     }
1041     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1042     if (clip) {
1043         clip->deleteEffect(index);
1044         emit clipItemSelected(clip);
1045     }
1046 }
1047
1048 void CustomTrackView::slotAddEffect(QDomElement effect, GenTime pos, int track) {
1049     QList<QGraphicsItem *> itemList;
1050     if (track == -1) itemList = scene()->selectedItems();
1051     if (itemList.isEmpty()) {
1052         ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, track);
1053         if (clip) itemList.append(clip);
1054         else emit displayMessage(i18n("Select a clip if you want to apply an effect"), ErrorMessage);
1055     }
1056     kDebug() << "// REQUESTING EFFECT ON CLIP: " << pos.frames(25) << ", TRK: " << track << "SELECTED ITEMS: " << itemList.count();
1057     for (int i = 0; i < itemList.count(); i++) {
1058         if (itemList.at(i)->type() == AVWIDGET) {
1059             ClipItem *item = (ClipItem *)itemList.at(i);
1060             item->initEffect(effect);
1061             if (effect.attribute("tag") == "ladspa") {
1062                 QString ladpsaFile = m_document->getLadspaFile();
1063                 initEffects::ladspaEffectFile(ladpsaFile, effect.attribute("ladspaid").toInt(), getLadspaParams(effect));
1064                 effect.setAttribute("src", ladpsaFile);
1065             }
1066             AddEffectCommand *command = new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), effect, true);
1067             m_commandStack->push(command);
1068         }
1069     }
1070     m_document->setModified(true);
1071 }
1072
1073 void CustomTrackView::slotDeleteEffect(ClipItem *clip, QDomElement effect) {
1074     AddEffectCommand *command = new AddEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), effect, false);
1075     m_commandStack->push(command);
1076     m_document->setModified(true);
1077 }
1078
1079 void CustomTrackView::updateEffect(int track, GenTime pos, QDomElement effect, int ix, bool triggeredByUser) {
1080     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1081     if (clip) {
1082         EffectsParameterList effectParams = clip->getEffectArgs(effect);
1083         if (effect.attribute("tag") == "ladspa") {
1084             // Update the ladspa affect file
1085             initEffects::ladspaEffectFile(effect.attribute("src"), effect.attribute("ladspaid").toInt(), getLadspaParams(effect));
1086         }
1087         // check if we are trying to reset a keyframe effect
1088         if (effectParams.hasParam("keyframes") && effectParams.paramValue("keyframes").isEmpty()) {
1089             clip->initEffect(effect);
1090             clip->setEffectAt(ix, effect);
1091             effectParams = clip->getEffectArgs(effect);
1092         }
1093         if (effectParams.paramValue("disabled") == "1") {
1094             if (m_document->renderer()->mltRemoveEffect(track, pos, effectParams.paramValue("kdenlive_ix"), false)) {
1095                 kDebug() << "//////  DISABLING EFFECT: " << index << ", CURRENTLA: " << clip->selectedEffectIndex();
1096             } else emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
1097         } else if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - clip->track(), clip->startPos(), effectParams))
1098             emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
1099
1100         clip->setEffectAt(ix, effect);
1101         if (ix == clip->selectedEffectIndex()) {
1102             clip->setSelectedEffect(ix);
1103             if (!triggeredByUser) emit clipItemSelected(clip, ix);
1104         }
1105         if (effect.attribute("tag") == "volume") {
1106             // A fade effect was modified, update the clip
1107             if (effect.attribute("id") == "fadein") {
1108                 int pos = effectParams.paramValue("out").toInt() - effectParams.paramValue("in").toInt();
1109                 clip->setFadeIn(pos);
1110             }
1111             if (effect.attribute("id") == "fadeout") {
1112                 int pos = effectParams.paramValue("out").toInt() - effectParams.paramValue("in").toInt();
1113                 clip->setFadeOut(pos);
1114             }
1115
1116         }
1117     }
1118     m_document->setModified(true);
1119 }
1120
1121 void CustomTrackView::moveEffect(int track, GenTime pos, int oldPos, int newPos) {
1122     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1123     if (clip) {
1124         m_document->renderer()->mltMoveEffect(track, pos, oldPos, newPos);
1125         QDomElement act = clip->effectAt(newPos - 1).cloneNode().toElement();
1126         QDomElement before = clip->effectAt(oldPos - 1).cloneNode().toElement();
1127         clip->setEffectAt(oldPos - 1, act);
1128         clip->setEffectAt(newPos - 1, before);
1129         emit clipItemSelected(clip, newPos - 1);
1130     }
1131     m_document->setModified(true);
1132 }
1133
1134 void CustomTrackView::slotChangeEffectState(ClipItem *clip, int effectPos, bool disable) {
1135     QDomElement effect = clip->effectAt(effectPos);
1136     QDomElement oldEffect = effect.cloneNode().toElement();
1137     effect.setAttribute("disabled", disable);
1138     EditEffectCommand *command = new EditEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), oldEffect, effect, effectPos, true);
1139     m_commandStack->push(command);
1140     m_document->setModified(true);
1141 }
1142
1143 void CustomTrackView::slotChangeEffectPosition(ClipItem *clip, int currentPos, int newPos) {
1144     MoveEffectCommand *command = new MoveEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), currentPos, newPos, true);
1145     m_commandStack->push(command);
1146     m_document->setModified(true);
1147 }
1148
1149 void CustomTrackView::slotUpdateClipEffect(ClipItem *clip, QDomElement oldeffect, QDomElement effect, int ix) {
1150     EditEffectCommand *command = new EditEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), oldeffect, effect, ix, true);
1151     m_commandStack->push(command);
1152 }
1153
1154 void CustomTrackView::cutClip(ItemInfo info, GenTime cutTime, bool cut) {
1155     if (cut) {
1156         // cut clip
1157         ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
1158         if (!item || cutTime >= item->endPos() || cutTime <= item->startPos()) {
1159             emit displayMessage(i18n("Cannot find clip to cut"), ErrorMessage);
1160             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);
1161             m_blockRefresh = false;
1162             return;
1163         }
1164         kDebug() << "/////////  CUTTING CLIP : (" << item->startPos().frames(25) << "-" << item->endPos().frames(25) << "), INFO: (" << info.startPos.frames(25) << "-" << info.endPos.frames(25) << ")" << ", CUT: " << cutTime.frames(25);
1165
1166         m_document->renderer()->mltCutClip(m_document->tracksCount() - info.track, cutTime);
1167         int cutPos = (int) cutTime.frames(m_document->fps());
1168         ItemInfo newPos;
1169         newPos.startPos = cutTime;
1170         newPos.endPos = info.endPos;
1171         newPos.cropStart = item->cropStart() + (cutTime - info.startPos);
1172         newPos.track = info.track;
1173         ClipItem *dup = item->clone(newPos);
1174         kDebug() << "// REsizing item to: " << cutPos;
1175         item->resizeEnd(cutPos, false);
1176         scene()->addItem(dup);
1177         if (item->checkKeyFrames()) slotRefreshEffects(item);
1178         if (dup->checkKeyFrames()) slotRefreshEffects(dup);
1179         item->baseClip()->addReference();
1180         m_document->updateClip(item->baseClip()->getId());
1181         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);
1182         kDebug() << "//  CUTTING CLIP dONE";
1183     } else {
1184         // uncut clip
1185
1186         ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
1187         ClipItem *dup = getClipItemAt((int) cutTime.frames(m_document->fps()) + 1, info.track);
1188         if (!item || !dup || item == dup) {
1189             emit displayMessage(i18n("Cannot find clip to uncut"), ErrorMessage);
1190             m_blockRefresh = false;
1191             return;
1192         }
1193         if (m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, cutTime) == false) {
1194             emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(cutTime.frames(m_document->fps())), info.track), ErrorMessage);
1195             return;
1196         }
1197
1198         kDebug() << "// UNCUTTING CLIPS: ITEM 1 (" << item->startPos().frames(25) << "x" << item->endPos().frames(25) << ")";
1199         kDebug() << "// UNCUTTING CLIPS: ITEM 2 (" << dup->startPos().frames(25) << "x" << dup->endPos().frames(25) << ")";
1200         kDebug() << "// UNCUTTING CLIPS, INFO (" << info.startPos.frames(25) << "x" << info.endPos.frames(25) << ") , CUT: " << cutTime.frames(25);;
1201         //deleteClip(dup->info());
1202
1203
1204         if (dup->isSelected()) emit clipItemSelected(NULL);
1205         dup->baseClip()->removeReference();
1206         m_document->updateClip(dup->baseClip()->getId());
1207         scene()->removeItem(dup);
1208         delete dup;
1209
1210         ItemInfo clipinfo = item->info();
1211         clipinfo.track = m_document->tracksCount() - clipinfo.track;
1212         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, info.endPos - info.startPos);
1213         if (success) {
1214             item->resizeEnd((int) info.endPos.frames(m_document->fps()));
1215         } else
1216             emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
1217
1218     }
1219     QTimer::singleShot(3000, this, SLOT(slotEnableRefresh()));
1220 }
1221
1222 void CustomTrackView::slotEnableRefresh() {
1223     m_blockRefresh = false;
1224 }
1225
1226 void CustomTrackView::slotAddTransitionToSelectedClips(QDomElement transition) {
1227     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1228     if (itemList.count() == 1) {
1229         if (itemList.at(0)->type() == AVWIDGET) {
1230             ClipItem *item = (ClipItem *) itemList.at(0);
1231             ItemInfo info;
1232             info.track = item->track();
1233             ClipItem *transitionClip = NULL;
1234             const int transitiontrack = getPreviousVideoTrack(info.track);
1235             GenTime pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
1236             if (pos < item->startPos() + item->duration() / 2) {
1237                 // add transition to clip start
1238                 info.startPos = item->startPos();
1239                 if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.startPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
1240                 if (transitionClip && transitionClip->endPos() < item->endPos()) {
1241                     info.endPos = transitionClip->endPos();
1242                 } else info.endPos = info.startPos + GenTime(65, m_document->fps());
1243                 // Check there is no other transition at that place
1244                 double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
1245                 QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
1246                 QList<QGraphicsItem *> selection = m_scene->items(r);
1247                 bool transitionAccepted = true;
1248                 for (int i = 0; i < selection.count(); i++) {
1249                     if (selection.at(i)->type() == TRANSITIONWIDGET) {
1250                         Transition *tr = static_cast <Transition *>(selection.at(i));
1251                         if (tr->startPos() - info.startPos > GenTime(5, m_document->fps())) {
1252                             if (tr->startPos() < info.endPos) info.endPos = tr->startPos();
1253                         } else transitionAccepted = false;
1254                     }
1255                 }
1256                 if (transitionAccepted) slotAddTransition(item, info, transitiontrack, transition);
1257                 else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1258
1259             } else {
1260                 // add transition to clip  end
1261                 info.endPos = item->endPos();
1262                 if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.endPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
1263                 if (transitionClip && transitionClip->startPos() > item->startPos()) {
1264                     info.startPos = transitionClip->startPos();
1265                 } else info.startPos = info.endPos - GenTime(65, m_document->fps());
1266                 if (transition.attribute("tag") == "luma") EffectsList::setParameter(transition, "reverse", "1");
1267
1268                 // Check there is no other transition at that place
1269                 double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
1270                 QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
1271                 QList<QGraphicsItem *> selection = m_scene->items(r);
1272                 bool transitionAccepted = true;
1273                 for (int i = 0; i < selection.count(); i++) {
1274                     if (selection.at(i)->type() == TRANSITIONWIDGET) {
1275                         Transition *tr = static_cast <Transition *>(selection.at(i));
1276                         if (info.endPos - tr->endPos() > GenTime(5, m_document->fps())) {
1277                             if (tr->endPos() > info.startPos) info.startPos = tr->endPos();
1278                         } else transitionAccepted = false;
1279                     }
1280                 }
1281                 if (transitionAccepted) slotAddTransition(item, info, transitiontrack, transition);
1282                 else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1283             }
1284         }
1285     } else for (int i = 0; i < itemList.count(); i++) {
1286             if (itemList.at(i)->type() == AVWIDGET) {
1287                 ClipItem *item = (ClipItem *) itemList.at(i);
1288                 ItemInfo info;
1289                 info.startPos = item->startPos();
1290                 info.endPos = info.startPos + GenTime(65, m_document->fps());
1291                 info.track = item->track();
1292
1293                 // Check there is no other transition at that place
1294                 double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
1295                 QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
1296                 QList<QGraphicsItem *> selection = m_scene->items(r);
1297                 bool transitionAccepted = true;
1298                 for (int i = 0; i < selection.count(); i++) {
1299                     if (selection.at(i)->type() == TRANSITIONWIDGET) {
1300                         Transition *tr = static_cast <Transition *>(selection.at(i));
1301                         if (tr->startPos() - info.startPos > GenTime(5, m_document->fps())) {
1302                             if (tr->startPos() < info.endPos) info.endPos = tr->startPos();
1303                         } else transitionAccepted = false;
1304                     }
1305                 }
1306                 int transitiontrack = getPreviousVideoTrack(info.track);
1307                 if (transitionAccepted) slotAddTransition(item, info, transitiontrack, transition);
1308                 else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1309             }
1310         }
1311 }
1312
1313 void CustomTrackView::slotAddTransition(ClipItem* clip, ItemInfo transitionInfo, int endTrack, QDomElement transition) {
1314     if (transitionInfo.startPos >= transitionInfo.endPos) {
1315         emit displayMessage(i18n("Invalid transition"), ErrorMessage);
1316         return;
1317     }
1318     AddTransitionCommand* command = new AddTransitionCommand(this, transitionInfo, endTrack, transition, false, true);
1319     m_commandStack->push(command);
1320     m_document->setModified(true);
1321 }
1322
1323 void CustomTrackView::addTransition(ItemInfo transitionInfo, int endTrack, QDomElement params) {
1324     Transition *tr = new Transition(transitionInfo, endTrack, m_document->fps(), params, true);
1325     //kDebug() << "---- ADDING transition " << params.attribute("value");
1326     if (m_document->renderer()->mltAddTransition(tr->transitionTag(), endTrack, m_document->tracksCount() - transitionInfo.track, transitionInfo.startPos, transitionInfo.endPos, tr->toXML())) {
1327         scene()->addItem(tr);
1328         m_document->setModified(true);
1329     } else {
1330         emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1331         delete tr;
1332     }
1333 }
1334
1335 void CustomTrackView::deleteTransition(ItemInfo transitionInfo, int endTrack, QDomElement params) {
1336     Transition *item = getTransitionItemAt(transitionInfo.startPos, transitionInfo.track);
1337     if (!item) {
1338         emit displayMessage(i18n("Select clip to delete"), ErrorMessage);
1339         return;
1340     }
1341     m_document->renderer()->mltDeleteTransition(item->transitionTag(), endTrack, m_document->tracksCount() - transitionInfo.track, transitionInfo.startPos, transitionInfo.endPos, item->toXML());
1342     if (m_dragItem == item) m_dragItem = NULL;
1343     delete item;
1344     emit transitionItemSelected(NULL);
1345     m_document->setModified(true);
1346 }
1347
1348 void CustomTrackView::slotTransitionUpdated(Transition *tr, QDomElement old) {
1349     kDebug() << "TRANS UPDATE, TRACKS: " << old.attribute("transition_btrack") << ", NEW: " << tr->toXML().attribute("transition_btrack");
1350     EditTransitionCommand *command = new EditTransitionCommand(this, tr->track(), tr->startPos(), old, tr->toXML(), false);
1351     m_commandStack->push(command);
1352     m_document->setModified(true);
1353 }
1354
1355 void CustomTrackView::updateTransition(int track, GenTime pos, QDomElement oldTransition, QDomElement transition, bool updateTransitionWidget) {
1356     Transition *item = getTransitionItemAt(pos, track);
1357     if (!item) {
1358         kWarning() << "Unable to find transition at pos :" << pos.frames(m_document->fps()) << ", ON track: " << track;
1359         return;
1360     }
1361     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);
1362     //kDebug() << "ORIGINAL TRACK: "<< oldTransition.attribute("transition_btrack") << ", NEW TRACK: "<<transition.attribute("transition_btrack");
1363     item->setTransitionParameters(transition);
1364     if (updateTransitionWidget) emit transitionItemSelected(item, true);
1365     m_document->setModified(true);
1366 }
1367
1368 void CustomTrackView::dragMoveEvent(QDragMoveEvent * event) {
1369     event->setDropAction(Qt::IgnoreAction);
1370     const QPointF pos = mapToScene(event->pos());
1371     if (m_selectionGroup) {
1372         m_selectionGroup->setPos(pos.x(), pos.y());
1373         event->setDropAction(Qt::MoveAction);
1374         if (event->mimeData()->hasFormat("kdenlive/producerslist") || event->mimeData()->hasFormat("kdenlive/clip")) {
1375             event->acceptProposedAction();
1376         }
1377     } else {
1378         QGraphicsView::dragMoveEvent(event);
1379     }
1380 }
1381
1382 void CustomTrackView::dragLeaveEvent(QDragLeaveEvent * event) {
1383     if (m_selectionGroup) {
1384         QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1385         qDeleteAll(items);
1386         scene()->destroyItemGroup(m_selectionGroup);
1387         m_selectionGroup = NULL;
1388     } else QGraphicsView::dragLeaveEvent(event);
1389 }
1390
1391 void CustomTrackView::dropEvent(QDropEvent * event) {
1392     if (m_selectionGroup) {
1393         QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1394         resetSelectionGroup();
1395         m_scene->clearSelection();
1396         for (int i = 0; i < items.count(); i++) {
1397             ClipItem *item = static_cast <ClipItem *>(items.at(i));
1398             AddTimelineClipCommand *command = new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, false);
1399             m_commandStack->push(command);
1400             item->baseClip()->addReference();
1401             m_document->updateClip(item->baseClip()->getId());
1402             ItemInfo info = item->info();
1403
1404             int tracknumber = m_document->tracksCount() - info.track - 1;
1405             bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
1406             if (isLocked) item->setItemLocked(true);
1407
1408             if (item->baseClip()->isTransparent()) {
1409                 // add transparency transition
1410                 int endTrack = getPreviousVideoTrack(info.track);
1411                 Transition *tr = new Transition(info, endTrack, m_document->fps(), MainWindow::transitions.getEffectByTag("composite", "composite"), true);
1412                 if (m_document->renderer()->mltAddTransition(tr->transitionTag(), endTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML())) {
1413                     scene()->addItem(tr);
1414                 } else {
1415                     emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1416                     delete tr;
1417                 }
1418             }
1419             info.track = m_document->tracksCount() - item->track();
1420             m_document->renderer()->mltInsertClip(info, item->xml(), item->baseClip()->producer(item->track()));
1421             item->setSelected(true);
1422         }
1423         groupSelectedItems(true);
1424         m_document->setModified(true);
1425     } else QGraphicsView::dropEvent(event);
1426     setFocus();
1427 }
1428
1429
1430 QStringList CustomTrackView::mimeTypes() const {
1431     QStringList qstrList;
1432     // list of accepted mime types for drop
1433     qstrList.append("text/plain");
1434     qstrList.append("kdenlive/producerslist");
1435     qstrList.append("kdenlive/clip");
1436     return qstrList;
1437 }
1438
1439 Qt::DropActions CustomTrackView::supportedDropActions() const {
1440     // returns what actions are supported when dropping
1441     return Qt::MoveAction;
1442 }
1443
1444 void CustomTrackView::setDuration(int duration) {
1445     if (duration > sceneRect().width())
1446         setSceneRect(0, 0, (duration + 100), sceneRect().height());
1447     m_projectDuration = duration;
1448 }
1449
1450 int CustomTrackView::duration() const {
1451     return m_projectDuration;
1452 }
1453
1454 void CustomTrackView::addTrack(TrackInfo type, int ix) {
1455     if (ix == -1) m_document->insertTrack(ix, type);
1456     else {
1457         m_document->insertTrack(m_document->tracksCount() - ix, type);
1458         // insert track in MLT playlist
1459         m_document->renderer()->mltInsertTrack(m_document->tracksCount() - ix, type.type == VIDEOTRACK);
1460
1461         double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
1462         QRectF r(0, startY, sceneRect().width(), sceneRect().height() - startY);
1463         QList<QGraphicsItem *> selection = m_scene->items(r);
1464         resetSelectionGroup();
1465
1466         m_selectionGroup = new AbstractGroupItem(m_document->fps());
1467         scene()->addItem(m_selectionGroup);
1468         for (int i = 0; i < selection.count(); i++) {
1469             if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET)
1470                 m_selectionGroup->addToGroup(selection.at(i));
1471             selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
1472         }
1473         // Move graphic items
1474         m_selectionGroup->translate(0, m_tracksHeight);
1475
1476         // adjust track number
1477         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
1478         for (int i = 0; i < children.count(); i++) {
1479             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
1480             item->updateItem();
1481             ItemInfo clipinfo = item->info();
1482             if (item->type() == AVWIDGET) {
1483                 ClipItem *clip = static_cast <ClipItem *>(item);
1484                 // We add a move clip command so that we get the correct producer for new track number
1485                 if (clip->clipType() == AV || clip->clipType() == AUDIO) {
1486                     m_document->renderer()->mltUpdateClipProducer((int)(m_document->tracksCount() - clipinfo.track), clipinfo.startPos.frames(m_document->fps()), clip->baseClip()->producer(clipinfo.track));
1487                     kDebug() << "// UPDATING CLIP TO TRACK PROD: " << clipinfo.track;
1488                 }
1489             } else if (item->type() == TRANSITIONWIDGET) {
1490                 Transition *tr = static_cast <Transition *>(item);
1491                 int track = tr->transitionEndTrack();
1492                 if (track >= ix) {
1493                     tr->updateTransitionEndTrack(getPreviousVideoTrack(clipinfo.track));
1494                 }
1495             }
1496         }
1497         resetSelectionGroup(false);
1498
1499     }
1500     int maxHeight = m_tracksHeight * m_document->tracksCount();
1501     for (int i = 0; i < m_guides.count(); i++) {
1502         QLineF l = m_guides.at(i)->line();
1503         l.setP2(QPointF(l.x2(), maxHeight));
1504         m_guides.at(i)->setLine(l);
1505     }
1506     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), maxHeight);
1507     setSceneRect(0, 0, sceneRect().width(), maxHeight);
1508     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
1509     viewport()->update();
1510     //setFixedHeight(50 * m_tracksCount);
1511 }
1512
1513 void CustomTrackView::removeTrack(int ix) {
1514     // Delete track in MLT playlist
1515     m_document->renderer()->mltDeleteTrack(m_document->tracksCount() - ix);
1516     m_document->deleteTrack(m_document->tracksCount() - ix - 1);
1517
1518     double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
1519     QRectF r(0, startY, sceneRect().width(), sceneRect().height() - startY);
1520     QList<QGraphicsItem *> selection = m_scene->items(r);
1521
1522     resetSelectionGroup();
1523
1524     m_selectionGroup = new AbstractGroupItem(m_document->fps());
1525     scene()->addItem(m_selectionGroup);
1526     for (int i = 0; i < selection.count(); i++) {
1527         if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET) {
1528             m_selectionGroup->addToGroup(selection.at(i));
1529             selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
1530         }
1531     }
1532     // Move graphic items
1533     qreal ydiff = 0 - (int) m_tracksHeight;
1534     m_selectionGroup->translate(0, ydiff);
1535
1536     // adjust track number
1537     QList<QGraphicsItem *> children = m_selectionGroup->childItems();
1538     //kDebug() << "// FOUND CLIPS TO MOVE: " << children.count();
1539     for (int i = 0; i < children.count(); i++) {
1540         if (children.at(i)->type() == AVWIDGET) {
1541             ClipItem *clip = static_cast <ClipItem *>(children.at(i));
1542             clip->updateItem();
1543             ItemInfo clipinfo = clip->info();
1544             kDebug() << "// CLIP TRK IS: " << clipinfo.track;
1545             // We add a move clip command so that we get the correct producer for new track number
1546             if (clip->clipType() == AV || clip->clipType() == AUDIO)
1547                 m_document->renderer()->mltUpdateClipProducer((int)(m_document->tracksCount() - clipinfo.track), clipinfo.startPos.frames(m_document->fps()), clip->baseClip()->producer(clipinfo.track));
1548         } else if (children.at(i)->type() == TRANSITIONWIDGET) {
1549             Transition *tr = static_cast <Transition *>(children.at(i));
1550             tr->updateItem();
1551             int track = tr->transitionEndTrack();
1552             if (track >= ix) {
1553                 ItemInfo clipinfo = tr->info();
1554                 tr->updateTransitionEndTrack(getPreviousVideoTrack(clipinfo.track));
1555             }
1556         }
1557     }
1558     resetSelectionGroup(false);
1559
1560     int maxHeight = m_tracksHeight * m_document->tracksCount();
1561     for (int i = 0; i < m_guides.count(); i++) {
1562         QLineF l = m_guides.at(i)->line();
1563         l.setP2(QPointF(l.x2(), maxHeight));
1564         m_guides.at(i)->setLine(l);
1565     }
1566     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), maxHeight);
1567     setSceneRect(0, 0, sceneRect().width(), maxHeight);
1568     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
1569     viewport()->update();
1570 }
1571
1572 void CustomTrackView::changeTrack(int ix, TrackInfo type) {
1573     int tracknumber = m_document->tracksCount() - ix;
1574     m_document->setTrackType(tracknumber - 1, type);
1575     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
1576     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
1577     viewport()->update();
1578 }
1579
1580
1581 void CustomTrackView::slotSwitchTrackAudio(int ix) {
1582     /*for (int i = 0; i < m_document->tracksCount(); i++)
1583         kDebug() << "TRK " << i << " STATE: " << m_document->trackInfoAt(i).isMute << m_document->trackInfoAt(i).isBlind;*/
1584     int tracknumber = m_document->tracksCount() - ix;
1585     m_document->switchTrackAudio(tracknumber - 1, !m_document->trackInfoAt(tracknumber - 1).isMute);
1586     kDebug() << "NEXT TRK STATE: " << m_document->trackInfoAt(tracknumber - 1).isMute << m_document->trackInfoAt(tracknumber - 1).isBlind;
1587     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
1588     m_document->setModified(true);
1589 }
1590
1591 void CustomTrackView::slotSwitchTrackLock(int ix) {
1592     int tracknumber = m_document->tracksCount() - ix - 1;
1593     LockTrackCommand *command = new LockTrackCommand(this, ix, !m_document->trackInfoAt(tracknumber).isLocked, true);
1594     m_commandStack->push(command);
1595 }
1596
1597
1598 void CustomTrackView::lockTrack(int ix, bool lock) {
1599     int tracknumber = m_document->tracksCount() - ix - 1;
1600     m_document->switchTrackLock(tracknumber, lock);
1601     emit doTrackLock(ix, lock);
1602     QList<QGraphicsItem *> selection = items(0, ix * m_tracksHeight + m_tracksHeight / 2, mapFromScene(sceneRect().width(), 0).x(), m_tracksHeight / 2 - 2);
1603
1604     for (int i = 0; i < selection.count(); i++) {
1605         if (selection.at(i)->type() != AVWIDGET && selection.at(i)->type() != TRANSITIONWIDGET) continue;
1606         if (selection.at(i)->isSelected()) {
1607             if (selection.at(i)->type() == AVWIDGET) emit clipItemSelected(NULL);
1608             else emit transitionItemSelected(NULL);
1609         }
1610         static_cast <AbstractClipItem *>(selection.at(i))->setItemLocked(lock);
1611     }
1612     kDebug() << "NEXT TRK STATE: " << m_document->trackInfoAt(tracknumber).isLocked;
1613     viewport()->update();
1614     m_document->setModified(true);
1615 }
1616
1617 void CustomTrackView::slotSwitchTrackVideo(int ix) {
1618     int tracknumber = m_document->tracksCount() - ix;
1619     m_document->switchTrackVideo(tracknumber - 1, !m_document->trackInfoAt(tracknumber - 1).isBlind);
1620     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
1621     m_document->setModified(true);
1622 }
1623
1624 void CustomTrackView::slotRemoveSpace() {
1625     GenTime pos;
1626     int track = 0;
1627     if (m_menuPosition.isNull()) {
1628         pos = GenTime(cursorPos(), m_document->fps());
1629         bool ok;
1630         track = QInputDialog::getInteger(this, i18n("Remove Space"), i18n("Track"), 0, 0, m_document->tracksCount() - 1, 1, &ok);
1631         if (!ok) return;
1632     } else {
1633         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
1634         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight);
1635     }
1636     ClipItem *item = getClipItemAt(pos, track);
1637     if (item) {
1638         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);
1639         return;
1640     }
1641     int length = m_document->renderer()->mltGetSpaceLength(pos, m_document->tracksCount() - track, true);
1642     //kDebug() << "// GOT LENGT; " << length;
1643     if (length <= 0) {
1644         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);
1645         return;
1646     }
1647
1648     QRectF r(pos.frames(m_document->fps()), track * m_tracksHeight + m_tracksHeight / 2, sceneRect().width() - pos.frames(m_document->fps()), m_tracksHeight / 2 - 1);
1649     QList<QGraphicsItem *> items = m_scene->items(r);
1650
1651     QList<ItemInfo> clipsToMove = QList<ItemInfo> ();
1652     QList<ItemInfo> transitionsToMove = QList<ItemInfo> ();
1653
1654     for (int i = 0; i < items.count(); i++) {
1655         if (items.at(i)->type() == AVWIDGET || items.at(i)->type() == TRANSITIONWIDGET) {
1656             AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
1657             ItemInfo info = item->info();
1658             if (item->type() == AVWIDGET) {
1659                 clipsToMove.append(info);
1660             } else if (item->type() == TRANSITIONWIDGET) {
1661                 transitionsToMove.append(info);
1662             }
1663         }
1664     }
1665
1666     InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, GenTime(-length, m_document->fps()), true);
1667     m_commandStack->push(command);
1668 }
1669
1670 void CustomTrackView::slotInsertSpace() {
1671     GenTime pos;
1672     int track = 0;
1673     if (m_menuPosition.isNull()) {
1674         pos = GenTime(cursorPos(), m_document->fps());
1675     } else {
1676         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
1677         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight) + 1;
1678     }
1679     SpacerDialog d(GenTime(65, m_document->fps()), m_document->timecode(), track, m_document->tracksCount(), this);
1680     if (d.exec() != QDialog::Accepted) return;
1681     GenTime spaceDuration = d.selectedDuration();
1682     track = d.selectedTrack();
1683     ClipItem *item = getClipItemAt(pos, track);
1684     if (item) pos = item->startPos();
1685
1686     int minh = 0;
1687     int maxh = sceneRect().height();
1688     if (track != -1) {
1689         minh = track * m_tracksHeight + m_tracksHeight / 2;
1690         maxh = m_tracksHeight / 2 - 1;
1691     }
1692
1693     QRectF r(pos.frames(m_document->fps()), minh, sceneRect().width() - pos.frames(m_document->fps()), maxh);
1694     QList<QGraphicsItem *> items = m_scene->items(r);
1695
1696     QList<ItemInfo> clipsToMove = QList<ItemInfo> ();
1697     QList<ItemInfo> transitionsToMove = QList<ItemInfo> ();
1698
1699     for (int i = 0; i < items.count(); i++) {
1700         if (items.at(i)->type() == AVWIDGET || items.at(i)->type() == TRANSITIONWIDGET) {
1701             AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
1702             ItemInfo info = item->info();
1703             if (item->type() == AVWIDGET) {
1704                 clipsToMove.append(info);
1705             } else if (item->type() == TRANSITIONWIDGET) {
1706                 transitionsToMove.append(info);
1707             }
1708         }
1709     }
1710
1711     InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, spaceDuration, true);
1712     m_commandStack->push(command);
1713 }
1714
1715 void CustomTrackView::insertSpace(QList<ItemInfo> clipsToMove, QList<ItemInfo> transToMove, int track, const GenTime duration, const GenTime offset) {
1716     int diff = duration.frames(m_document->fps());
1717     resetSelectionGroup();
1718     m_selectionGroup = new AbstractGroupItem(m_document->fps());
1719     scene()->addItem(m_selectionGroup);
1720     ClipItem *clip;
1721     Transition *transition;
1722
1723     kDebug() << "/// STARTING SPACE INSERT";
1724
1725
1726     // Create lists with start pos for each track
1727     QMap <int, int> trackClipStartList;
1728     QMap <int, int> trackTransitionStartList;
1729
1730     for (int i = 1; i < m_document->tracksCount() + 1; i++) {
1731         trackClipStartList[i] = -1;
1732         trackTransitionStartList[i] = -1;
1733     }
1734
1735     if (!clipsToMove.isEmpty()) for (int i = 0; i < clipsToMove.count(); i++) {
1736             kDebug() << "/// FETCHING CLIP: " << i;
1737             clip = getClipItemAtStart(clipsToMove.at(i).startPos + offset, clipsToMove.at(i).track);
1738             if (clip) {
1739                 m_selectionGroup->addToGroup(clip);
1740                 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))
1741                     trackClipStartList[m_document->tracksCount() - clipsToMove.at(i).track] = clipsToMove.at(i).startPos.frames(m_document->fps());
1742                 clip->setFlags(QGraphicsItem::ItemIsSelectable);
1743             } 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);
1744         }
1745     if (!transToMove.isEmpty()) for (int i = 0; i < transToMove.count(); i++) {
1746             kDebug() << "/// FETCHING TRANS: " << i;
1747             transition = getTransitionItemAtStart(transToMove.at(i).startPos + offset, transToMove.at(i).track);
1748             if (transition) {
1749                 m_selectionGroup->addToGroup(transition);
1750                 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))
1751                     trackTransitionStartList[m_document->tracksCount() - transToMove.at(i).track] = transToMove.at(i).startPos.frames(m_document->fps());
1752                 transition->setFlags(QGraphicsItem::ItemIsSelectable);
1753             } 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);
1754         }
1755     kDebug() << "/// STARTING SPACE DONE";
1756     m_selectionGroup->translate(diff, 0);
1757     resetSelectionGroup(false);
1758     kDebug() << "/// STARTING SPACE DONE2";
1759     if (track != -1) track = m_document->tracksCount() - track;
1760     m_document->renderer()->mltInsertSpace(trackClipStartList, trackTransitionStartList, track, duration, offset);
1761 }
1762
1763 void CustomTrackView::deleteClip(const QString &clipId) {
1764     QList<QGraphicsItem *> itemList = items();
1765     for (int i = 0; i < itemList.count(); i++) {
1766         if (itemList.at(i)->type() == AVWIDGET) {
1767             ClipItem *item = (ClipItem *)itemList.at(i);
1768             if (item->clipProducer() == clipId) {
1769                 AddTimelineClipCommand *command = new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true);
1770                 m_commandStack->push(command);
1771                 //delete item;
1772             }
1773         }
1774     }
1775 }
1776
1777 void CustomTrackView::setCursorPos(int pos, bool seek) {
1778     emit cursorMoved((int)(m_cursorPos), (int)(pos));
1779     m_cursorPos = pos;
1780     m_cursorLine->setPos(pos, 0);
1781     if (seek) m_document->renderer()->seek(GenTime(pos, m_document->fps()));
1782     else if (m_autoScroll) checkScrolling();
1783 }
1784
1785 void CustomTrackView::updateCursorPos() {
1786     m_cursorLine->setPos(m_cursorPos, 0);
1787 }
1788
1789 int CustomTrackView::cursorPos() {
1790     return (int)(m_cursorPos);
1791 }
1792
1793 void CustomTrackView::moveCursorPos(int delta) {
1794     if (m_cursorPos + delta < 0) delta = 0 - m_cursorPos;
1795     emit cursorMoved((int)(m_cursorPos), (int)((m_cursorPos + delta)));
1796     m_cursorPos += delta;
1797     m_cursorLine->setPos(m_cursorPos, 0);
1798     m_document->renderer()->seek(GenTime(m_cursorPos, m_document->fps()));
1799 }
1800
1801 void CustomTrackView::initCursorPos(int pos) {
1802     emit cursorMoved((int)(m_cursorPos), (int)(pos));
1803     m_cursorPos = pos;
1804     m_cursorLine->setPos(pos, 0);
1805     checkScrolling();
1806 }
1807
1808 void CustomTrackView::checkScrolling() {
1809     int vert = verticalScrollBar()->value();
1810     int hor = cursorPos();
1811     ensureVisible(hor, vert + 10, 2, 2, 50, 0);
1812 }
1813
1814 void CustomTrackView::mouseReleaseEvent(QMouseEvent * event) {
1815     if (m_moveOpMode == SEEK) m_moveOpMode = NONE;
1816     QGraphicsView::mouseReleaseEvent(event);
1817     if (m_scrollTimer.isActive()) m_scrollTimer.stop();
1818     if (event->button() == Qt::MidButton) {
1819         return;
1820     }
1821     setDragMode(QGraphicsView::NoDrag);
1822     if (m_operationMode == MOVEGUIDE) {
1823         setCursor(Qt::ArrowCursor);
1824         m_operationMode = NONE;
1825         m_dragGuide->setFlag(QGraphicsItem::ItemIsMovable, false);
1826         EditGuideCommand *command = new EditGuideCommand(this, m_dragGuide->position(), m_dragGuide->label(), GenTime(m_dragGuide->pos().x(), m_document->fps()), m_dragGuide->label(), false);
1827         m_commandStack->push(command);
1828         m_dragGuide->updateGuide(GenTime(m_dragGuide->pos().x(), m_document->fps()));
1829         m_dragGuide = NULL;
1830         m_dragItem = NULL;
1831         return;
1832     } else if (m_operationMode == SPACER) {
1833         int endClick = (int)(mapToScene(event->pos()).x() + 0.5);
1834         int mappedClick = (int)(mapToScene(m_clickEvent).x() + 0.5);
1835         int track = (int)(mapToScene(m_clickEvent).y() / m_tracksHeight);
1836         if (m_selectionGroup->sceneBoundingRect().height() > m_tracksHeight) {
1837             // We are moving all tracks
1838             track = -1;
1839         }
1840         GenTime timeOffset = GenTime(m_selectionGroup->scenePos().x(), m_document->fps()) - m_selectionGroupInfo.startPos;
1841         if (timeOffset != GenTime()) {
1842             QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1843
1844             QList<ItemInfo> clipsToMove = QList<ItemInfo> ();
1845             QList<ItemInfo> transitionsToMove = QList<ItemInfo> ();
1846
1847             // Create lists with start pos for each track
1848             QMap <int, int> trackClipStartList;
1849             QMap <int, int> trackTransitionStartList;
1850
1851             for (int i = 1; i < m_document->tracksCount() + 1; i++) {
1852                 trackClipStartList[i] = -1;
1853                 trackTransitionStartList[i] = -1;
1854             }
1855
1856             for (int i = 0; i < items.count(); i++) {
1857                 AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
1858                 ItemInfo info = item->info();
1859                 if (item->type() == AVWIDGET) {
1860                     clipsToMove.append(info);
1861                     if (trackClipStartList.value(m_document->tracksCount() - info.track) == -1 || info.startPos.frames(m_document->fps()) < trackClipStartList.value(m_document->tracksCount() - info.track))
1862                         trackClipStartList[m_document->tracksCount() - info.track] = info.startPos.frames(m_document->fps());
1863                 } else if (item->type() == TRANSITIONWIDGET) {
1864                     transitionsToMove.append(info);
1865                     if (trackClipStartList.value(m_document->tracksCount() - info.track) == -1 || info.startPos.frames(m_document->fps()) < trackTransitionStartList.value(m_document->tracksCount() - info.track))
1866                         trackTransitionStartList[m_document->tracksCount() - info.track] = info.startPos.frames(m_document->fps());
1867                 }
1868             }
1869
1870             InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, timeOffset, false);
1871             m_commandStack->push(command);
1872             if (track != -1) track = m_document->tracksCount() - track;
1873             m_document->renderer()->mltInsertSpace(trackClipStartList, trackTransitionStartList, track, timeOffset, GenTime());
1874         }
1875         resetSelectionGroup(false);
1876         m_operationMode = NONE;
1877     } else if (m_operationMode == RUBBERSELECTION) {
1878         kDebug() << "// END RUBBER SELECT";
1879         resetSelectionGroup();
1880         groupSelectedItems();
1881         m_operationMode = NONE;
1882     }
1883
1884     if (m_dragItem == NULL && m_selectionGroup == NULL) {
1885         emit transitionItemSelected(NULL);
1886         return;
1887     }
1888     ItemInfo info;
1889     if (m_dragItem) info = m_dragItem->info();
1890
1891     if (m_operationMode == MOVE) {
1892         setCursor(Qt::OpenHandCursor);
1893
1894         if (m_selectionGroup == NULL) {
1895             // we are moving one clip, easy
1896             if (m_dragItem->type() == AVWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
1897                 ClipItem *item = static_cast <ClipItem *>(m_dragItem);
1898                 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));
1899                 if (success) {
1900                     int tracknumber = m_document->tracksCount() - item->track() - 1;
1901                     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
1902                     if (isLocked) item->setItemLocked(true);
1903
1904                     QUndoCommand *moveCommand = new QUndoCommand();
1905                     moveCommand->setText(i18n("Move clip"));
1906                     new MoveClipCommand(this, m_dragItemInfo, info, false, moveCommand);
1907                     // Also move automatic transitions (on lower track)
1908                     Transition *tr = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track);
1909                     if (tr && tr->isAutomatic()) {
1910                         ItemInfo trInfo = tr->info();
1911                         ItemInfo newTrInfo = trInfo;
1912                         newTrInfo.track = info.track;
1913                         newTrInfo.startPos = m_dragItem->startPos();
1914                         if (m_dragItemInfo.track == info.track && !item->baseClip()->isTransparent() && getClipItemAtEnd(newTrInfo.endPos, m_document->tracksCount() - tr->transitionEndTrack())) {
1915                             // transition end should stay the same
1916                         } else {
1917                             // transition end should be adjusted to clip
1918                             newTrInfo.endPos = newTrInfo.endPos + (newTrInfo.startPos - trInfo.startPos);
1919                         }
1920                         if (newTrInfo.startPos < newTrInfo.endPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
1921                     }
1922                     if (tr == NULL || tr->endPos() < m_dragItemInfo.endPos) {
1923                         // Check if there is a transition at clip end
1924                         tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track);
1925                         if (tr && tr->isAutomatic()) {
1926                             ItemInfo trInfo = tr->info();
1927                             ItemInfo newTrInfo = trInfo;
1928                             newTrInfo.track = info.track;
1929                             newTrInfo.endPos = m_dragItem->endPos();
1930                             if (m_dragItemInfo.track == info.track && !item->baseClip()->isTransparent() && getClipItemAtStart(trInfo.startPos, m_document->tracksCount() - tr->transitionEndTrack())) {
1931                                 // transition start should stay the same
1932                             } else {
1933                                 // transition start should be moved
1934                                 newTrInfo.startPos = newTrInfo.startPos + (newTrInfo.endPos - trInfo.endPos);
1935                             }
1936                             if (newTrInfo.startPos < newTrInfo.endPos)
1937                                 new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
1938                         }
1939                     }
1940                     // Also move automatic transitions (on upper track)
1941                     tr = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
1942                     if (m_dragItemInfo.track == info.track && tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
1943                         ItemInfo trInfo = tr->info();
1944                         ItemInfo newTrInfo = trInfo;
1945                         newTrInfo.startPos = m_dragItem->startPos();
1946                         ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
1947                         if (!upperClip || !upperClip->baseClip()->isTransparent()) {
1948                             if (!getClipItemAtEnd(newTrInfo.endPos, tr->track())) {
1949                                 // transition end should be adjusted to clip on upper track
1950                                 newTrInfo.endPos = newTrInfo.endPos + (newTrInfo.startPos - trInfo.startPos);
1951                             }
1952                             if (newTrInfo.startPos < newTrInfo.endPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
1953                         }
1954                     }
1955                     if (m_dragItemInfo.track == info.track && (tr == NULL || tr->endPos() < m_dragItemInfo.endPos)) {
1956                         // Check if there is a transition at clip end
1957                         tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
1958                         if (tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
1959                             ItemInfo trInfo = tr->info();
1960                             ItemInfo newTrInfo = trInfo;
1961                             newTrInfo.endPos = m_dragItem->endPos();
1962                             ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
1963                             if (!upperClip || !upperClip->baseClip()->isTransparent()) {
1964                                 if (!getClipItemAtStart(trInfo.startPos, tr->track())) {
1965                                     // transition start should be moved
1966                                     newTrInfo.startPos = newTrInfo.startPos + (newTrInfo.endPos - trInfo.endPos);
1967                                 }
1968                                 if (newTrInfo.startPos < newTrInfo.endPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
1969                             }
1970                         }
1971                     }
1972                     m_commandStack->push(moveCommand);
1973                 } else {
1974                     // undo last move and emit error message
1975                     MoveClipCommand *command = new MoveClipCommand(this, info, m_dragItemInfo, true);
1976                     m_commandStack->push(command);
1977                     emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(m_dragItemInfo.startPos.frames(m_document->fps()))), ErrorMessage);
1978                 }
1979             }
1980             if (m_dragItem->type() == TRANSITIONWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
1981                 Transition *transition = static_cast <Transition *>(m_dragItem);
1982                 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)) {
1983                     // Moving transition failed, revert to previous position
1984                     emit displayMessage(i18n("Cannot move transition"), ErrorMessage);
1985                     transition->setPos((int) m_dragItemInfo.startPos.frames(m_document->fps()), (m_dragItemInfo.track) * m_tracksHeight + 1);
1986                 } else {
1987                     MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
1988                     m_commandStack->push(command);
1989                     transition->updateTransitionEndTrack(getPreviousVideoTrack(m_dragItem->track()));
1990                 }
1991             }
1992         } else {
1993             // Moving several clips. We need to delete them and readd them to new position,
1994             // or they might overlap each other during the move
1995
1996             QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1997
1998             QList<ItemInfo> clipsToMove = QList<ItemInfo> ();
1999             QList<ItemInfo> transitionsToMove = QList<ItemInfo> ();
2000
2001             GenTime timeOffset = GenTime(m_selectionGroup->scenePos().x(), m_document->fps()) - m_selectionGroupInfo.startPos;
2002             const int trackOffset = m_selectionGroup->track() - m_selectionGroupInfo.track;
2003             if (timeOffset != GenTime() || trackOffset != 0) {
2004                 QUndoCommand *moveClips = new QUndoCommand();
2005                 moveClips->setText(i18n("Move group"));
2006                 // remove items in MLT playlist
2007                 for (int i = 0; i < items.count(); i++) {
2008                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2009                     ItemInfo info = item->info();
2010                     if (item->type() == AVWIDGET) {
2011                         if (m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
2012                             // error, clip cannot be removed from playlist
2013                             emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
2014                         } else {
2015                             clipsToMove.append(info);
2016                         }
2017                     } else {
2018                         transitionsToMove.append(info);
2019                         Transition *tr = static_cast <Transition*>(item);
2020                         m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2021                     }
2022                 }
2023
2024                 for (int i = 0; i < items.count(); i++) {
2025                     // re-add items in correct place
2026                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2027                     item->updateItem();
2028                     ItemInfo info = item->info();
2029                     int tracknumber = m_document->tracksCount() - info.track - 1;
2030                     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2031                     if (isLocked) {
2032                         m_selectionGroup->removeFromGroup(item);
2033                         item->setItemLocked(true);
2034                     }
2035
2036                     if (item->type() == AVWIDGET) {
2037                         ClipItem *clip = static_cast <ClipItem*>(item);
2038                         info.track = m_document->tracksCount() - info.track;
2039                         m_document->renderer()->mltInsertClip(info, clip->xml(), clip->baseClip()->producer(info.track));
2040                         for (int i = 0; i < clip->effectsCount(); i++) {
2041                             m_document->renderer()->mltAddEffect(info.track, info.startPos, clip->getEffectArgs(clip->effectAt(i)), false);
2042                         }
2043                     } else {
2044                         Transition *tr = static_cast <Transition*>(item);
2045                         int newTrack = tr->transitionEndTrack();
2046                         if (!tr->forcedTrack()) {
2047                             newTrack = getPreviousVideoTrack(info.track);
2048                         }
2049                         tr->updateTransitionEndTrack(newTrack);
2050                         m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2051                     }
2052                 }
2053
2054                 new MoveGroupCommand(this, clipsToMove, transitionsToMove, timeOffset, trackOffset, false, moveClips);
2055                 m_commandStack->push(moveClips);
2056
2057                 QPointF top = m_selectionGroup->sceneBoundingRect().topLeft();
2058                 //QPointF oldpos = m_selectionGroup->scenePos();
2059                 //kDebug()<<"SELECTION GRP POS: "<<m_selectionGroup->scenePos()<<", TOP: "<<top;
2060                 m_selectionGroup->setPos(top);
2061                 m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
2062                 m_selectionGroupInfo.track = m_selectionGroup->track();
2063             }
2064         }
2065
2066     } else if (m_operationMode == RESIZESTART && m_dragItem->startPos() != m_dragItemInfo.startPos) {
2067         // resize start
2068         if (m_dragItem->type() == AVWIDGET) {
2069             ItemInfo resizeinfo = m_dragItemInfo;
2070             resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
2071             bool success = m_document->renderer()->mltResizeClipStart(resizeinfo, m_dragItem->startPos() - m_dragItemInfo.startPos);
2072             if (success) {
2073                 QUndoCommand *resizeCommand = new QUndoCommand();
2074                 resizeCommand->setText(i18n("Resize clip"));
2075
2076                 // Check if there is an automatic transition on that clip (lower track)
2077                 Transition *transition = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track);
2078                 if (transition && transition->isAutomatic()) {
2079                     ItemInfo trInfo = transition->info();
2080                     ItemInfo newTrInfo = trInfo;
2081                     newTrInfo.startPos = m_dragItem->startPos();
2082                     if (newTrInfo.startPos < newTrInfo.endPos)
2083                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2084                 }
2085                 // Check if there is an automatic transition on that clip (upper track)
2086                 transition = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2087                 if (transition && transition->isAutomatic() && (m_document->tracksCount() - transition->transitionEndTrack()) == m_dragItemInfo.track) {
2088                     ItemInfo trInfo = transition->info();
2089                     ItemInfo newTrInfo = trInfo;
2090                     newTrInfo.startPos = m_dragItem->startPos();
2091                     ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2092                     if ((!upperClip || !upperClip->baseClip()->isTransparent()) && newTrInfo.startPos < newTrInfo.endPos) {
2093                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2094                     }
2095                 }
2096                 updateClipFade(static_cast <ClipItem *>(m_dragItem));
2097                 new ResizeClipCommand(this, m_dragItemInfo, info, false, resizeCommand);
2098                 m_commandStack->push(resizeCommand);
2099             } else {
2100                 m_dragItem->resizeStart((int) m_dragItemInfo.startPos.frames(m_document->fps()));
2101                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2102             }
2103         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
2104             Transition *transition = static_cast <Transition *>(m_dragItem);
2105             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)) {
2106                 // Cannot resize transition
2107                 transition->resizeStart((int) m_dragItemInfo.startPos.frames(m_document->fps()));
2108                 emit displayMessage(i18n("Cannot resize transition"), ErrorMessage);
2109             } else {
2110                 MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
2111                 m_commandStack->push(command);
2112             }
2113
2114         }
2115
2116         //m_document->renderer()->doRefresh();
2117     } else if (m_operationMode == RESIZEEND && m_dragItem->endPos() != m_dragItemInfo.endPos) {
2118         // resize end
2119         if (m_dragItem->type() == AVWIDGET) {
2120             ItemInfo resizeinfo = info;
2121             resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
2122             bool success = m_document->renderer()->mltResizeClipEnd(resizeinfo, resizeinfo.endPos - resizeinfo.startPos);
2123             if (success) {
2124                 QUndoCommand *resizeCommand = new QUndoCommand();
2125                 resizeCommand->setText(i18n("Resize clip"));
2126
2127                 // Check if there is an automatic transition on that clip (lower track)
2128                 Transition *tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track);
2129                 if (tr && tr->isAutomatic()) {
2130                     ItemInfo trInfo = tr->info();
2131                     ItemInfo newTrInfo = trInfo;
2132                     newTrInfo.endPos = m_dragItem->endPos();
2133                     if (newTrInfo.endPos > newTrInfo.startPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2134                 }
2135
2136                 // Check if there is an automatic transition on that clip (upper track)
2137                 tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
2138                 if (tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
2139                     ItemInfo trInfo = tr->info();
2140                     ItemInfo newTrInfo = trInfo;
2141                     newTrInfo.endPos = m_dragItem->endPos();
2142                     ClipItem * upperClip = getClipItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
2143                     if ((!upperClip || !upperClip->baseClip()->isTransparent()) && newTrInfo.endPos > newTrInfo.startPos) {
2144                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2145                     }
2146                 }
2147
2148                 new ResizeClipCommand(this, m_dragItemInfo, info, false, resizeCommand);
2149                 m_commandStack->push(resizeCommand);
2150                 updateClipFade(static_cast <ClipItem *>(m_dragItem), true);
2151             } else {
2152                 m_dragItem->resizeEnd((int) m_dragItemInfo.endPos.frames(m_document->fps()));
2153                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2154             }
2155         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
2156             Transition *transition = static_cast <Transition *>(m_dragItem);
2157             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)) {
2158                 // Cannot resize transition
2159                 transition->resizeEnd((int) m_dragItemInfo.endPos.frames(m_document->fps()));
2160                 emit displayMessage(i18n("Cannot resize transition"), ErrorMessage);
2161             } else {
2162                 MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
2163                 m_commandStack->push(command);
2164             }
2165         }
2166         //m_document->renderer()->doRefresh();
2167     } else if (m_operationMode == FADEIN) {
2168         // resize fade in effect
2169         ClipItem * item = (ClipItem *) m_dragItem;
2170         int ix = item->hasEffect("volume", "fadein");
2171         if (ix != -1) {
2172             QDomElement oldeffect = item->effectAt(ix);
2173             int start = item->cropStart().frames(m_document->fps());
2174             int end = item->fadeIn();
2175             if (end == 0) {
2176                 slotDeleteEffect(item, oldeffect);
2177             } else {
2178                 end += start;
2179                 QDomElement effect = oldeffect.cloneNode().toElement();
2180                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2181                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2182                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2183                 emit clipItemSelected(item, ix);
2184             }
2185         } else if (item->fadeIn() != 0) {
2186             QDomElement effect = MainWindow::audioEffects.getEffectByTag("volume", "fadein").cloneNode().toElement();
2187             EffectsList::setParameter(effect, "out", QString::number(item->fadeIn()));
2188             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
2189         }
2190     } else if (m_operationMode == FADEOUT) {
2191         // resize fade in effect
2192         ClipItem * item = (ClipItem *) m_dragItem;
2193         int ix = item->hasEffect("volume", "fadeout");
2194         if (ix != -1) {
2195             QDomElement oldeffect = item->effectAt(ix);
2196             int end = (item->duration() + item->cropStart()).frames(m_document->fps());
2197             int start = item->fadeOut();
2198             if (start == 0) {
2199                 slotDeleteEffect(item, oldeffect);
2200             } else {
2201                 start = end - start;
2202                 QDomElement effect = oldeffect.cloneNode().toElement();
2203                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2204                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2205                 // kDebug()<<"EDIT FADE OUT : "<<start<<"x"<<end;
2206                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2207                 emit clipItemSelected(item, ix);
2208             }
2209         } else if (item->fadeOut() != 0) {
2210             QDomElement effect = MainWindow::audioEffects.getEffectByTag("volume", "fadeout").cloneNode().toElement();
2211             EffectsList::setParameter(effect, "in", QString::number(item->fadeOut()));
2212             EffectsList::setParameter(effect, "out", QString::number(0));
2213             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
2214         }
2215     } else if (m_operationMode == KEYFRAME) {
2216         // update the MLT effect
2217         ClipItem * item = (ClipItem *) m_dragItem;
2218         QString previous = item->keyframes(item->selectedEffectIndex());
2219         item->updateKeyframeEffect();
2220         QString next = item->keyframes(item->selectedEffectIndex());
2221         EditKeyFrameCommand *command = new EditKeyFrameCommand(this, item->track(), item->startPos(), item->selectedEffectIndex(), previous, next, false);
2222         m_commandStack->push(command);
2223         updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
2224     }
2225
2226     emit transitionItemSelected((m_dragItem && m_dragItem->type() == TRANSITIONWIDGET && m_dragItem->isSelected()) ? static_cast <Transition *>(m_dragItem) : NULL);
2227     m_document->setModified(true);
2228     m_operationMode = NONE;
2229 }
2230
2231 void CustomTrackView::deleteClip(ItemInfo info) {
2232     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
2233
2234     if (!item || m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
2235         emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
2236         return;
2237     }
2238     if (item->isSelected()) emit clipItemSelected(NULL);
2239     item->baseClip()->removeReference();
2240     m_document->updateClip(item->baseClip()->getId());
2241
2242     if (item->baseClip()->isTransparent()) {
2243         // also remove automatic transition
2244         Transition *tr = getTransitionItemAt(info.startPos, info.track);
2245         if (tr && tr->isAutomatic()) {
2246             m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2247             scene()->removeItem(tr);
2248             delete tr;
2249         }
2250     }
2251     scene()->removeItem(item);
2252     if (m_dragItem == item) m_dragItem = NULL;
2253     delete item;
2254     m_document->renderer()->doRefresh();
2255 }
2256
2257 void CustomTrackView::deleteSelectedClips() {
2258     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2259     if (itemList.count() == 0) {
2260         emit displayMessage(i18n("Select clip to delete"), ErrorMessage);
2261         return;
2262     }
2263     QUndoCommand *deleteSelected = new QUndoCommand();
2264     deleteSelected->setText(i18n("Delete selected items"));
2265     for (int i = 0; i < itemList.count(); i++) {
2266         if (itemList.at(i)->type() == AVWIDGET) {
2267             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2268             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true, deleteSelected);
2269         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
2270             Transition *item = static_cast <Transition *>(itemList.at(i));
2271             ItemInfo info;
2272             info.startPos = item->startPos();
2273             info.endPos = item->endPos();
2274             info.track = item->track();
2275             new AddTransitionCommand(this, info, item->transitionEndTrack(), item->toXML(), true, true, deleteSelected);
2276         }
2277     }
2278     m_commandStack->push(deleteSelected);
2279 }
2280
2281 void CustomTrackView::changeClipSpeed() {
2282     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2283     if (itemList.count() == 0) {
2284         emit displayMessage(i18n("Select clip to change speed"), ErrorMessage);
2285         return;
2286     }
2287     QUndoCommand *changeSelected = new QUndoCommand();
2288     changeSelected->setText("Edit clip speed");
2289     int count = 0;
2290     for (int i = 0; i < itemList.count(); i++) {
2291         if (itemList.at(i)->type() == AVWIDGET) {
2292             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2293             ItemInfo info = item->info();
2294             bool ok;
2295             int percent = QInputDialog::getInteger(this, i18n("Edit Clip Speed"), i18n("New speed (percents)"), item->speed() * 100, 1, 300, 1, &ok);
2296             double speed = (double) percent / 100.0;
2297             if (ok && item->speed() != speed) {
2298                 count++;
2299                 new ChangeSpeedCommand(this, info, item->speed(), speed, item->clipProducer(), true, changeSelected);
2300             }
2301         }
2302     }
2303     if (count > 0) m_commandStack->push(changeSelected);
2304     else delete changeSelected;
2305 }
2306
2307 void CustomTrackView::doChangeClipSpeed(ItemInfo info, const double speed, const double oldspeed, const QString &id) {
2308     DocClipBase *baseclip = m_document->clipManager()->getClipById(id);
2309     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
2310     info.track = m_document->tracksCount() - item->track();
2311     int endPos = m_document->renderer()->mltChangeClipSpeed(info, speed, oldspeed, baseclip->producer());
2312     //kDebug() << "//CH CLIP SPEED: " << speed << "x" << oldspeed << ", END POS: " << endPos;
2313     item->setSpeed(speed);
2314     item->updateRectGeometry();
2315     if (item->cropDuration().frames(m_document->fps()) > endPos)
2316         item->AbstractClipItem::resizeEnd(info.startPos.frames(m_document->fps()) + endPos, speed);
2317     m_document->setModified(true);
2318 }
2319
2320 void CustomTrackView::cutSelectedClips() {
2321     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2322     GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
2323     for (int i = 0; i < itemList.count(); i++) {
2324         if (itemList.at(i)->type() == AVWIDGET) {
2325             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2326             if (currentPos > item->startPos() && currentPos <  item->endPos()) {
2327                 RazorClipCommand *command = new RazorClipCommand(this, item->info(), currentPos, true);
2328                 m_commandStack->push(command);
2329             }
2330         }
2331     }
2332 }
2333
2334 void CustomTrackView::addClip(QDomElement xml, const QString &clipId, ItemInfo info, EffectsList effects) {
2335     DocClipBase *baseclip = m_document->clipManager()->getClipById(clipId);
2336     if (baseclip == NULL) {
2337         emit displayMessage(i18n("No clip copied"), ErrorMessage);
2338         return;
2339     }
2340     ClipItem *item = new ClipItem(baseclip, info, m_document->fps(), xml.attribute("speed", "1").toDouble());
2341     item->setEffectList(effects);
2342     scene()->addItem(item);
2343
2344     int tracknumber = m_document->tracksCount() - info.track - 1;
2345     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2346     if (isLocked) item->setItemLocked(true);
2347
2348     if (item->baseClip()->isTransparent()) {
2349         // add transparency transition
2350         int endTrack = getPreviousVideoTrack(info.track);
2351         Transition *tr = new Transition(info, endTrack, m_document->fps(), MainWindow::transitions.getEffectByTag("composite", "composite"), true);
2352         if (m_document->renderer()->mltAddTransition(tr->transitionTag(), endTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML())) scene()->addItem(tr);
2353         else {
2354             emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
2355             delete tr;
2356         }
2357
2358     }
2359
2360     baseclip->addReference();
2361     m_document->updateClip(baseclip->getId());
2362     info.track = m_document->tracksCount() - info.track;
2363     m_document->renderer()->mltInsertClip(info, xml, baseclip->producer(info.track));
2364     for (int i = 0; i < item->effectsCount(); i++) {
2365         m_document->renderer()->mltAddEffect(info.track, info.startPos, item->getEffectArgs(item->effectAt(i)), false);
2366     }
2367     m_document->renderer()->doRefresh();
2368 }
2369
2370 void CustomTrackView::slotUpdateClip(const QString &clipId) {
2371     QList<QGraphicsItem *> list = scene()->items();
2372     ClipItem *clip = NULL;
2373     for (int i = 0; i < list.size(); ++i) {
2374         if (list.at(i)->type() == AVWIDGET) {
2375             clip = static_cast <ClipItem *>(list.at(i));
2376             if (clip->clipProducer() == clipId) {
2377                 clip->refreshClip();
2378                 ItemInfo info = clip->info();
2379                 info.track = m_document->tracksCount() - clip->track();
2380                 m_document->renderer()->mltUpdateClip(info, clip->xml(), clip->baseClip()->producer());
2381             }
2382         }
2383     }
2384 }
2385
2386 ClipItem *CustomTrackView::getClipItemAtEnd(GenTime pos, int track) {
2387     int framepos = (int)(pos.frames(m_document->fps()));
2388     QList<QGraphicsItem *> list = scene()->items(QPointF(framepos - 1, track * m_tracksHeight + m_tracksHeight / 2));
2389     ClipItem *clip = NULL;
2390     for (int i = 0; i < list.size(); i++) {
2391         if (list.at(i)->type() == AVWIDGET) {
2392             ClipItem *test = static_cast <ClipItem *>(list.at(i));
2393             if (test->endPos() == pos) clip = test;
2394             break;
2395         }
2396     }
2397     return clip;
2398 }
2399
2400 ClipItem *CustomTrackView::getClipItemAtStart(GenTime pos, int track) {
2401     QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), track * m_tracksHeight + m_tracksHeight / 2));
2402     ClipItem *clip = NULL;
2403     for (int i = 0; i < list.size(); i++) {
2404         if (list.at(i)->type() == AVWIDGET) {
2405             ClipItem *test = static_cast <ClipItem *>(list.at(i));
2406             if (test->startPos() == pos) clip = test;
2407             break;
2408         }
2409     }
2410     return clip;
2411 }
2412
2413 ClipItem *CustomTrackView::getClipItemAt(int pos, int track) {
2414     QList<QGraphicsItem *> list = scene()->items(QPointF(pos , track * m_tracksHeight + m_tracksHeight / 2));
2415     ClipItem *clip = NULL;
2416     for (int i = 0; i < list.size(); i++) {
2417         if (list.at(i)->type() == AVWIDGET) {
2418             clip = static_cast <ClipItem *>(list.at(i));
2419             break;
2420         }
2421     }
2422     return clip;
2423 }
2424
2425 ClipItem *CustomTrackView::getClipItemAt(GenTime pos, int track) {
2426     int framepos = (int)(pos.frames(m_document->fps()));
2427     return getClipItemAt(framepos, track);
2428 }
2429
2430 Transition *CustomTrackView::getTransitionItemAt(GenTime pos, int track) {
2431     QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), (track + 1) * m_tracksHeight));
2432     Transition *clip = NULL;
2433     for (int i = 0; i < list.size(); i++) {
2434         if (list.at(i)->type() == TRANSITIONWIDGET) {
2435             clip = static_cast <Transition *>(list.at(i));
2436             break;
2437         }
2438     }
2439     return clip;
2440 }
2441
2442 Transition *CustomTrackView::getTransitionItemAtEnd(GenTime pos, int track) {
2443     int framepos = (int)(pos.frames(m_document->fps()));
2444     QList<QGraphicsItem *> list = scene()->items(QPointF(framepos - 1, (track + 1) * m_tracksHeight));
2445     Transition *clip = NULL;
2446     for (int i = 0; i < list.size(); i++) {
2447         if (list.at(i)->type() == TRANSITIONWIDGET) {
2448             Transition *test = static_cast <Transition *>(list.at(i));
2449             if (test->endPos() == pos) clip = test;
2450             break;
2451         }
2452     }
2453     return clip;
2454 }
2455
2456 Transition *CustomTrackView::getTransitionItemAtStart(GenTime pos, int track) {
2457     QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), (track + 1) * m_tracksHeight));
2458     Transition *clip = NULL;
2459     for (int i = 0; i < list.size(); ++i) {
2460         if (list.at(i)->type() == TRANSITIONWIDGET) {
2461             Transition *test = static_cast <Transition *>(list.at(i));
2462             if (test->startPos() == pos) clip = test;
2463             break;
2464         }
2465     }
2466     return clip;
2467 }
2468
2469 void CustomTrackView::moveClip(const ItemInfo start, const ItemInfo end) {
2470     if (m_selectionGroup) resetSelectionGroup(false);
2471     ClipItem *item = getClipItemAt((int) start.startPos.frames(m_document->fps()) + 1, start.track);
2472     if (!item) {
2473         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);
2474         kDebug() << "----------------  ERROR, CANNOT find clip to move at.. ";
2475         return;
2476     }
2477     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));
2478     if (success) {
2479         bool snap = KdenliveSettings::snaptopoints();
2480         KdenliveSettings::setSnaptopoints(false);
2481         item->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
2482
2483         int tracknumber = m_document->tracksCount() - end.track - 1;
2484         bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2485         m_scene->clearSelection();
2486         if (isLocked) item->setItemLocked(true);
2487         else {
2488             if (item->isItemLocked()) item->setItemLocked(false);
2489             item->setSelected(true);
2490         }
2491         if (item->baseClip()->isTransparent()) {
2492             // Also move automatic transition
2493             Transition *tr = getTransitionItemAt(start.startPos, start.track);
2494             if (tr && tr->isAutomatic()) {
2495                 tr->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
2496                 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);
2497                 tr->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
2498             }
2499         }
2500         KdenliveSettings::setSnaptopoints(snap);
2501     } else {
2502         // undo last move and emit error message
2503         emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(end.startPos.frames(m_document->fps()))), ErrorMessage);
2504     }
2505     kDebug() << " // MOVED CLIP TO: " << end.startPos.frames(25) << ", ITEM START: " << item->startPos().frames(25);
2506 }
2507
2508 void CustomTrackView::moveGroup(QList <ItemInfo> startClip, QList <ItemInfo> startTransition, const GenTime offset, const int trackOffset, bool reverseMove) {
2509     // Group Items
2510     kDebug() << "// GROUP MOVE; OFFSET: " << offset.frames(25) << ", TK OFF: " << trackOffset;
2511     resetSelectionGroup();
2512     m_scene->clearSelection();
2513     for (int i = 0; i < startClip.count(); i++) {
2514         if (reverseMove) {
2515             startClip[i].startPos = startClip.at(i).startPos - offset;
2516             startClip[i].track = startClip.at(i).track - trackOffset;
2517         }
2518         ClipItem *clip = getClipItemAt(startClip.at(i).startPos, startClip.at(i).track);
2519         if (clip) {
2520             clip->setItemLocked(false);
2521             clip->setSelected(true);
2522             m_document->renderer()->mltRemoveClip(m_document->tracksCount() - startClip.at(i).track, startClip.at(i).startPos);
2523         }
2524     }
2525     for (int i = 0; i < startTransition.count(); i++) {
2526         if (reverseMove) {
2527             startTransition[i].startPos = startTransition.at(i).startPos - offset;
2528             startTransition[i].track = startTransition.at(i).track - trackOffset;
2529         }
2530         Transition *tr = getTransitionItemAt(startTransition.at(i).startPos, startTransition.at(i).track);
2531         if (tr) {
2532             tr->setItemLocked(false);
2533             tr->setSelected(true);
2534             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());
2535         }
2536     }
2537     groupSelectedItems();
2538     if (m_selectionGroup) {
2539         QPointF pos = m_selectionGroup->pos();
2540         qreal posx = pos.x() + offset.frames(m_document->fps());
2541         qreal posy = pos.y() + trackOffset * (qreal) m_tracksHeight;
2542         bool snap = KdenliveSettings::snaptopoints();
2543         KdenliveSettings::setSnaptopoints(false);
2544
2545         m_selectionGroup->setPos(posx, posy);
2546
2547         QPointF top = m_selectionGroup->sceneBoundingRect().topLeft();
2548         m_selectionGroup->setPos(top);
2549         m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
2550         m_selectionGroupInfo.track = m_selectionGroup->track();
2551
2552         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
2553         for (int i = 0; i < children.count(); i++) {
2554             // re-add items in correct place
2555             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
2556             item->updateItem();
2557             ItemInfo info = item->info();
2558             int tracknumber = m_document->tracksCount() - info.track - 1;
2559             bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2560             if (isLocked) item->setItemLocked(true);
2561             else if (item->isItemLocked()) item->setItemLocked(false);
2562
2563             if (item->type() == AVWIDGET) {
2564                 ClipItem *clip = static_cast <ClipItem*>(item);
2565                 info.track = m_document->tracksCount() - info.track;
2566                 m_document->renderer()->mltInsertClip(info, clip->xml(), clip->baseClip()->producer(info.track));
2567             } else {
2568                 Transition *tr = static_cast <Transition*>(item);
2569                 int newTrack = tr->transitionEndTrack();
2570                 kDebug() << "/// TRANSITION CURR TRK: " << newTrack;
2571                 if (!tr->forcedTrack()) {
2572                     newTrack += trackOffset;
2573                     if (newTrack < 0 || newTrack > m_document->tracksCount()) newTrack = getPreviousVideoTrack(info.track);
2574                 }
2575                 tr->updateTransitionEndTrack(newTrack);
2576                 kDebug() << "/// TRANSITION UPDATED TRK: " << newTrack;
2577                 m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2578             }
2579         }
2580         KdenliveSettings::setSnaptopoints(snap);
2581     }
2582
2583 }
2584
2585 void CustomTrackView::moveTransition(const ItemInfo start, const ItemInfo end) {
2586     Transition *item = getTransitionItemAt(start.startPos, start.track);
2587     if (!item) {
2588         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);
2589         kDebug() << "----------------  ERROR, CANNOT find transition to move... ";// << startPos.x() * m_scale * FRAME_SIZE + 1 << ", " << startPos.y() * m_tracksHeight + m_tracksHeight / 2;
2590         return;
2591     }
2592     //kDebug() << "----------------  Move TRANSITION FROM: " << startPos.x() << ", END:" << endPos.x() << ",TRACKS: " << oldtrack << " TO " << newtrack;
2593     bool snap = KdenliveSettings::snaptopoints();
2594     KdenliveSettings::setSnaptopoints(false);
2595     //kDebug()<<"///  RESIZE TRANS START: ("<< startPos.x()<<"x"<< startPos.y()<<") / ("<<endPos.x()<<"x"<< endPos.y()<<")";
2596     if (end.endPos - end.startPos == start.endPos - start.startPos) {
2597         // Transition was moved
2598         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
2599     } else if (end.endPos == start.endPos) {
2600         // Transition start resize
2601         item->resizeStart((int) end.startPos.frames(m_document->fps()));
2602     } else if (end.startPos == start.startPos) {
2603         // Transition end resize;
2604         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
2605     } else {
2606         // Move & resize
2607         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
2608         item->resizeStart((int) end.startPos.frames(m_document->fps()));
2609         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
2610     }
2611     //item->moveTransition(GenTime((int) (endPos.x() - startPos.x()), m_document->fps()));
2612     KdenliveSettings::setSnaptopoints(snap);
2613     item->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
2614     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);
2615 }
2616
2617 void CustomTrackView::resizeClip(const ItemInfo start, const ItemInfo end) {
2618     int offset = 0;
2619     bool resizeClipStart = true;
2620     if (start.startPos == end.startPos) resizeClipStart = false;
2621     /*if (resizeClipStart) offset = 1;
2622     else offset = -1;*/
2623     ClipItem *item = getClipItemAt((int)(start.startPos.frames(m_document->fps()) + offset), start.track);
2624     if (!item) {
2625         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);
2626         kDebug() << "----------------  ERROR, CANNOT find clip to resize at... "; // << startPos;
2627         return;
2628     }
2629     bool snap = KdenliveSettings::snaptopoints();
2630     KdenliveSettings::setSnaptopoints(false);
2631     if (resizeClipStart) {
2632         ItemInfo clipinfo = item->info();
2633         clipinfo.track = m_document->tracksCount() - clipinfo.track;
2634         bool success = m_document->renderer()->mltResizeClipStart(clipinfo, end.startPos - item->startPos());
2635         if (success) {
2636             item->resizeStart((int) end.startPos.frames(m_document->fps()));
2637             updateClipFade(item);
2638         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2639     } else {
2640         ItemInfo clipinfo = item->info();
2641         clipinfo.track = m_document->tracksCount() - clipinfo.track;
2642         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, end.endPos - clipinfo.startPos);
2643         if (success) {
2644             item->resizeEnd((int) end.endPos.frames(m_document->fps()));
2645             updateClipFade(item, true);
2646         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2647     }
2648     m_document->renderer()->doRefresh();
2649     KdenliveSettings::setSnaptopoints(snap);
2650 }
2651
2652 void CustomTrackView::updateClipFade(ClipItem * item, bool updateFadeOut) {
2653     if (!updateFadeOut) {
2654         int end = item->fadeIn();
2655         if (end != 0) {
2656             // there is a fade in effect
2657             int effectPos = item->hasEffect("volume", "fadein");
2658             if (effectPos == -1) return;
2659             QDomElement oldeffect = item->effectAt(effectPos);
2660             int start = item->cropStart().frames(m_document->fps());
2661             int max = item->cropDuration().frames(m_document->fps());
2662             if (end > max) {
2663                 item->setFadeIn(max);
2664                 end = item->fadeIn();
2665             }
2666             end += start;
2667             EffectsList::setParameter(oldeffect, "in", QString::number(start));
2668             EffectsList::setParameter(oldeffect, "out", QString::number(end));
2669             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
2670                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
2671             // if fade effect is displayed, update the effect edit widget with new clip duration
2672             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
2673         }
2674     } else {
2675         int start = item->fadeOut();
2676         if (start != 0) {
2677             // there is a fade in effect
2678             int effectPos = item->hasEffect("volume", "fadeout");
2679             if (effectPos == -1) return;
2680             QDomElement oldeffect = item->effectAt(effectPos);
2681             int end = (item->duration() - item->cropStart()).frames(m_document->fps());
2682             int max = item->cropDuration().frames(m_document->fps());
2683             if (end > max) {
2684                 item->setFadeOut(max);
2685                 start = item->fadeOut();
2686             }
2687             start = end - start;
2688             EffectsList::setParameter(oldeffect, "in", QString::number(start));
2689             EffectsList::setParameter(oldeffect, "out", QString::number(end));
2690             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
2691                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
2692             // if fade effect is displayed, update the effect edit widget with new clip duration
2693             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
2694         }
2695     }
2696 }
2697
2698 double CustomTrackView::getSnapPointForPos(double pos) {
2699     return m_scene->getSnapPointForPos(pos, KdenliveSettings::snaptopoints());
2700 }
2701
2702 void CustomTrackView::updateSnapPoints(AbstractClipItem *selected) {
2703     QList <GenTime> snaps;
2704     GenTime offset;
2705     if (selected) offset = selected->duration();
2706     QList<QGraphicsItem *> itemList = items();
2707     for (int i = 0; i < itemList.count(); i++) {
2708         if (itemList.at(i)->type() == AVWIDGET && itemList.at(i) != selected) {
2709             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2710             GenTime start = item->startPos();
2711             GenTime end = item->endPos();
2712             snaps.append(start);
2713             snaps.append(end);
2714             QList < GenTime > markers = item->snapMarkers();
2715             for (int i = 0; i < markers.size(); ++i) {
2716                 GenTime t = markers.at(i);
2717                 snaps.append(t);
2718                 if (t > offset) snaps.append(t - offset);
2719             }
2720             if (offset != GenTime()) {
2721                 if (start > offset) snaps.append(start - offset);
2722                 if (end > offset) snaps.append(end - offset);
2723             }
2724         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
2725             Transition *transition = static_cast <Transition*>(itemList.at(i));
2726             GenTime start = transition->startPos();
2727             GenTime end = transition->endPos();
2728             snaps.append(start);
2729             snaps.append(end);
2730             if (offset != GenTime()) {
2731                 if (start > offset) snaps.append(start - offset);
2732                 if (end > offset) snaps.append(end - offset);
2733             }
2734         }
2735     }
2736
2737     // add cursor position
2738     GenTime pos = GenTime(m_cursorPos, m_document->fps());
2739     snaps.append(pos);
2740     if (offset != GenTime()) snaps.append(pos - offset);
2741
2742     // add guides
2743     for (int i = 0; i < m_guides.count(); i++) {
2744         snaps.append(m_guides.at(i)->position());
2745         if (offset != GenTime()) snaps.append(m_guides.at(i)->position() - offset);
2746     }
2747
2748     qSort(snaps);
2749     m_scene->setSnapList(snaps);
2750     //for (int i = 0; i < m_snapPoints.size(); ++i)
2751     //    kDebug() << "SNAP POINT: " << m_snapPoints.at(i).frames(25);
2752 }
2753
2754 void CustomTrackView::slotSeekToPreviousSnap() {
2755     updateSnapPoints(NULL);
2756     GenTime res = m_scene->previousSnapPoint(GenTime(m_cursorPos, m_document->fps()));
2757     setCursorPos((int) res.frames(m_document->fps()));
2758     checkScrolling();
2759 }
2760
2761 void CustomTrackView::slotSeekToNextSnap() {
2762     updateSnapPoints(NULL);
2763     GenTime res = m_scene->nextSnapPoint(GenTime(m_cursorPos, m_document->fps()));
2764     setCursorPos((int) res.frames(m_document->fps()));
2765     checkScrolling();
2766 }
2767
2768 void CustomTrackView::clipStart() {
2769     ClipItem *item = getMainActiveClip();
2770     if (item != NULL) {
2771         setCursorPos((int) item->startPos().frames(m_document->fps()));
2772         checkScrolling();
2773     }
2774 }
2775
2776 void CustomTrackView::clipEnd() {
2777     ClipItem *item = getMainActiveClip();
2778     if (item != NULL) {
2779         setCursorPos((int) item->endPos().frames(m_document->fps()) - 1);
2780         checkScrolling();
2781     }
2782 }
2783
2784 void CustomTrackView::slotAddClipMarker(const QString &id, GenTime t, QString c) {
2785     QString oldcomment = m_document->clipManager()->getClipById(id)->markerComment(t);
2786     AddMarkerCommand *command = new AddMarkerCommand(this, oldcomment, c, id, t, true);
2787     m_commandStack->push(command);
2788 }
2789
2790 void CustomTrackView::slotDeleteClipMarker(const QString &comment, const QString &id, const GenTime &position) {
2791     AddMarkerCommand *command = new AddMarkerCommand(this, comment, QString(), id, position, true);
2792     m_commandStack->push(command);
2793 }
2794
2795 void CustomTrackView::slotDeleteAllClipMarkers(const QString &id) {
2796     DocClipBase *base = m_document->clipManager()->getClipById(id);
2797     QList <CommentedTime> markers = base->commentedSnapMarkers();
2798
2799     if (markers.isEmpty()) {
2800         emit displayMessage(i18n("Clip has no markers"), ErrorMessage);
2801         return;
2802     }
2803     QUndoCommand *deleteMarkers = new QUndoCommand();
2804     deleteMarkers->setText("Delete clip markers");
2805
2806     for (int i = 0; i < markers.size(); i++) {
2807         new AddMarkerCommand(this, markers.at(i).comment(), QString(), id, markers.at(i).time(), true, deleteMarkers);
2808     }
2809     m_commandStack->push(deleteMarkers);
2810 }
2811
2812 void CustomTrackView::addMarker(const QString &id, const GenTime &pos, const QString comment) {
2813     DocClipBase *base = m_document->clipManager()->getClipById(id);
2814     if (!comment.isEmpty()) base->addSnapMarker(pos, comment);
2815     else base->deleteSnapMarker(pos);
2816     m_document->setModified(true);
2817     viewport()->update();
2818 }
2819
2820 bool sortGuidesList(const Guide *g1 , const Guide *g2) {
2821     return (*g1).position() < (*g2).position();
2822 }
2823
2824 void CustomTrackView::editGuide(const GenTime oldPos, const GenTime pos, const QString &comment) {
2825     if (oldPos > GenTime() && pos > GenTime()) {
2826         // move guide
2827         for (int i = 0; i < m_guides.count(); i++) {
2828             if (m_guides.at(i)->position() == oldPos) {
2829                 Guide *item = m_guides.at(i);
2830                 item->updateGuide(pos, comment);
2831                 break;
2832             }
2833         }
2834     } else if (pos > GenTime()) addGuide(pos, comment);
2835     else {
2836         // remove guide
2837         bool found = false;
2838         for (int i = 0; i < m_guides.count(); i++) {
2839             if (m_guides.at(i)->position() == oldPos) {
2840                 Guide *item = m_guides.takeAt(i);
2841                 delete item;
2842                 found = true;
2843                 break;
2844             }
2845         }
2846         if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
2847     }
2848     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
2849     m_document->syncGuides(m_guides);
2850 }
2851
2852 bool CustomTrackView::addGuide(const GenTime pos, const QString &comment) {
2853     for (int i = 0; i < m_guides.count(); i++) {
2854         if (m_guides.at(i)->position() == pos) {
2855             emit displayMessage(i18n("A guide already exists at position %1", m_document->timecode().getTimecodeFromFrames(pos.frames(m_document->fps()))), ErrorMessage);
2856             return false;
2857         }
2858     }
2859     Guide *g = new Guide(this, pos, comment, m_document->fps(), m_tracksHeight * m_document->tracksCount());
2860     scene()->addItem(g);
2861     m_guides.append(g);
2862     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
2863     m_document->syncGuides(m_guides);
2864     return true;
2865 }
2866
2867 void CustomTrackView::slotAddGuide() {
2868     CommentedTime marker(GenTime(m_cursorPos, m_document->fps()), i18n("Guide"));
2869     MarkerDialog d(NULL, marker, m_document->timecode(), i18n("Add Guide"), this);
2870     if (d.exec() != QDialog::Accepted) return;
2871     if (addGuide(d.newMarker().time(), d.newMarker().comment())) {
2872         EditGuideCommand *command = new EditGuideCommand(this, GenTime(), QString(), d.newMarker().time(), d.newMarker().comment(), false);
2873         m_commandStack->push(command);
2874     }
2875 }
2876
2877 void CustomTrackView::slotEditGuide() {
2878     GenTime pos = GenTime(m_cursorPos, m_document->fps());
2879     bool found = false;
2880     for (int i = 0; i < m_guides.count(); i++) {
2881         if (m_guides.at(i)->position() == pos) {
2882             slotEditGuide(m_guides.at(i)->info());
2883             found = true;
2884             break;
2885         }
2886     }
2887     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
2888 }
2889
2890 void CustomTrackView::slotEditGuide(CommentedTime guide) {
2891     MarkerDialog d(NULL, guide, m_document->timecode(), i18n("Edit Guide"), this);
2892     if (d.exec() == QDialog::Accepted) {
2893         EditGuideCommand *command = new EditGuideCommand(this, guide.time(), guide.comment(), d.newMarker().time(), d.newMarker().comment(), true);
2894         m_commandStack->push(command);
2895     }
2896 }
2897
2898
2899 void CustomTrackView::slotDeleteGuide() {
2900     GenTime pos = GenTime(m_cursorPos, m_document->fps());
2901     bool found = false;
2902     for (int i = 0; i < m_guides.count(); i++) {
2903         if (m_guides.at(i)->position() == pos) {
2904             EditGuideCommand *command = new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true);
2905             m_commandStack->push(command);
2906             found = true;
2907             break;
2908         }
2909     }
2910     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
2911 }
2912
2913 void CustomTrackView::slotDeleteAllGuides() {
2914     QUndoCommand *deleteAll = new QUndoCommand();
2915     deleteAll->setText("Delete all guides");
2916     for (int i = 0; i < m_guides.count(); i++) {
2917         EditGuideCommand *command = new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true, deleteAll);
2918     }
2919     m_commandStack->push(deleteAll);
2920 }
2921
2922 void CustomTrackView::setTool(PROJECTTOOL tool) {
2923     m_tool = tool;
2924 }
2925
2926 void CustomTrackView::setScale(double scaleFactor) {
2927     QMatrix matrix;
2928     matrix = matrix.scale(scaleFactor, 1);
2929     m_scene->setScale(scaleFactor);
2930     //scale(scaleFactor, 1);
2931     m_animationTimer->stop();
2932     if (m_visualTip) {
2933         delete m_visualTip;
2934         m_visualTip = NULL;
2935     }
2936     if (m_animation) {
2937         delete m_animation;
2938         m_animation = NULL;
2939     }
2940     /*double pos = cursorPos() / m_scale;
2941     m_scale = scaleFactor;
2942     m_scene->setScale(m_scale);
2943     int vert = verticalScrollBar()->value();
2944     kDebug() << " HHHHHHHH  SCALING: " << m_scale;
2945     QList<QGraphicsItem *> itemList = items();
2946     for (int i = 0; i < itemList.count(); i++) {
2947         if (itemList.at(i)->type() == AVWIDGET || itemList.at(i)->type() == TRANSITIONWIDGET) {
2948             AbstractClipItem *clip = (AbstractClipItem *)itemList.at(i);
2949             clip->setRect(0, 0, (qreal) clip->duration().frames(m_document->fps()) * m_scale - .5, clip->rect().height());
2950             clip->setPos((qreal) clip->startPos().frames(m_document->fps()) * m_scale, clip->pos().y());
2951         }
2952     }
2953
2954     for (int i = 0; i < m_guides.count(); i++) {
2955         m_guides.at(i)->updatePosition(m_scale);
2956     }
2957
2958     setSceneRect(0, 0, (m_projectDuration + 100) * m_scale, sceneRect().height());
2959     updateCursorPos();*/
2960     setMatrix(matrix);
2961     centerOn(QPointF(cursorPos(), m_tracksHeight));
2962     //verticalScrollBar()->setValue(vert);*/
2963 }
2964
2965 void CustomTrackView::slotRefreshGuides() {
2966     if (KdenliveSettings::showmarkers()) {
2967         kDebug() << "// refresh GUIDES";
2968         for (int i = 0; i < m_guides.count(); i++) {
2969             m_guides.at(i)->update();
2970         }
2971     }
2972 }
2973
2974 void CustomTrackView::drawBackground(QPainter * painter, const QRectF & rect) {
2975     QColor base = palette().button().color();
2976     QRectF r = rect;
2977     r.setWidth(r.width() + 1);
2978     painter->setClipRect(r);
2979     painter->drawLine(r.left(), 0, r.right(), 0);
2980     uint max = m_document->tracksCount();
2981     for (uint i = 0; i < max;i++) {
2982         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)));
2983         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)));
2984         painter->drawLine(r.left(), m_tracksHeight * (i + 1), r.right(), m_tracksHeight * (i + 1));
2985     }
2986     int lowerLimit = m_tracksHeight * m_document->tracksCount() + 1;
2987     if (height() > lowerLimit)
2988         painter->fillRect(QRectF(r.left(), lowerLimit, r.width(), height() - lowerLimit), QBrush(base));
2989 }
2990
2991 bool CustomTrackView::findString(const QString &text) {
2992     QString marker;
2993     for (int i = 0; i < m_searchPoints.size(); ++i) {
2994         marker = m_searchPoints.at(i).comment();
2995         if (marker.contains(text, Qt::CaseInsensitive)) {
2996             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
2997             int vert = verticalScrollBar()->value();
2998             int hor = cursorPos();
2999             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
3000             m_findIndex = i;
3001             return true;
3002         }
3003     }
3004     return false;
3005 }
3006
3007 bool CustomTrackView::findNextString(const QString &text) {
3008     QString marker;
3009     for (int i = m_findIndex + 1; i < m_searchPoints.size(); ++i) {
3010         marker = m_searchPoints.at(i).comment();
3011         if (marker.contains(text, Qt::CaseInsensitive)) {
3012             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
3013             int vert = verticalScrollBar()->value();
3014             int hor = cursorPos();
3015             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
3016             m_findIndex = i;
3017             return true;
3018         }
3019     }
3020     m_findIndex = -1;
3021     return false;
3022 }
3023
3024 void CustomTrackView::initSearchStrings() {
3025     m_searchPoints.clear();
3026     QList<QGraphicsItem *> itemList = items();
3027     for (int i = 0; i < itemList.count(); i++) {
3028         // parse all clip names
3029         if (itemList.at(i)->type() == AVWIDGET) {
3030             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
3031             GenTime start = item->startPos();
3032             CommentedTime t(start, item->clipName());
3033             m_searchPoints.append(t);
3034             // add all clip markers
3035             QList < CommentedTime > markers = item->commentedSnapMarkers();
3036             m_searchPoints += markers;
3037         }
3038     }
3039
3040     // add guides
3041     for (int i = 0; i < m_guides.count(); i++) {
3042         m_searchPoints.append(m_guides.at(i)->info());
3043     }
3044
3045     qSort(m_searchPoints);
3046 }
3047
3048 void CustomTrackView::clearSearchStrings() {
3049     m_searchPoints.clear();
3050     m_findIndex = 0;
3051 }
3052
3053 void CustomTrackView::copyClip() {
3054     while (m_copiedItems.count() > 0) {
3055         delete m_copiedItems.takeFirst();
3056     }
3057     QList<QGraphicsItem *> itemList = scene()->selectedItems();
3058     if (itemList.count() == 0) {
3059         emit displayMessage(i18n("Select a clip before copying"), ErrorMessage);
3060         return;
3061     }
3062     for (int i = 0; i < itemList.count(); i++) {
3063         if (itemList.at(i)->type() == AVWIDGET) {
3064             ClipItem *dup = static_cast <ClipItem *>(itemList.at(i));
3065             m_copiedItems.append(dup->clone(dup->info()));
3066         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
3067             Transition *dup = static_cast <Transition *>(itemList.at(i));
3068             m_copiedItems.append(dup->clone());
3069         }
3070     }
3071 }
3072
3073 bool CustomTrackView::canBePastedTo(ItemInfo info, int type) const {
3074     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));
3075     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
3076     for (int i = 0; i < collisions.count(); i++) {
3077         if (collisions.at(i)->type() == type) return false;
3078     }
3079     return true;
3080 }
3081
3082 bool CustomTrackView::canBePasted(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const {
3083     for (int i = 0; i < items.count(); i++) {
3084         ItemInfo info = items.at(i)->info();
3085         info.startPos += offset;
3086         info.endPos += offset;
3087         info.track += trackOffset;
3088         if (!canBePastedTo(info, items.at(i)->type())) return false;
3089     }
3090     return true;
3091 }
3092
3093 bool CustomTrackView::canBeMoved(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const {
3094     QPainterPath movePath;
3095     movePath.moveTo(0, 0);
3096
3097     for (int i = 0; i < items.count(); i++) {
3098         ItemInfo info = items.at(i)->info();
3099         info.startPos = info.startPos + offset;
3100         info.endPos = info.endPos + offset;
3101         info.track = info.track + trackOffset;
3102         if (info.startPos < GenTime()) {
3103             // No clip should go below 0
3104             return false;
3105         }
3106         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));
3107         movePath.addRect(rect);
3108     }
3109     QList<QGraphicsItem *> collisions = scene()->items(movePath, Qt::IntersectsItemBoundingRect);
3110     for (int i = 0; i < collisions.count(); i++) {
3111         if ((collisions.at(i)->type() == AVWIDGET || collisions.at(i)->type() == TRANSITIONWIDGET) && !items.contains(static_cast <AbstractClipItem *>(collisions.at(i)))) {
3112             kDebug() << "  ////////////   CLIP COLLISION, MOVE NOT ALLOWED";
3113             return false;
3114         }
3115     }
3116     return true;
3117 }
3118
3119 void CustomTrackView::pasteClip() {
3120     if (m_copiedItems.count() == 0) {
3121         emit displayMessage(i18n("No clip copied"), ErrorMessage);
3122         return;
3123     }
3124     QPoint position;
3125     if (m_menuPosition.isNull()) {
3126         position = mapFromGlobal(QCursor::pos());
3127         if (!underMouse() || position.y() > m_tracksHeight * m_document->tracksCount()) {
3128             emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
3129             return;
3130         }
3131     } else position = m_menuPosition;
3132     GenTime pos = GenTime((int)(mapToScene(position).x()), m_document->fps());
3133     int track = (int)(position.y() / m_tracksHeight);
3134     ItemInfo first = m_copiedItems.at(0)->info();
3135
3136     GenTime offset = pos - first.startPos;
3137     int trackOffset = track - first.track;
3138
3139     if (!canBePasted(m_copiedItems, offset, trackOffset)) {
3140         emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
3141         return;
3142     }
3143     QUndoCommand *pasteClips = new QUndoCommand();
3144     pasteClips->setText("Paste clips");
3145
3146     for (int i = 0; i < m_copiedItems.count(); i++) {
3147         // parse all clip names
3148         if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == AVWIDGET) {
3149             ClipItem *clip = static_cast <ClipItem *>(m_copiedItems.at(i));
3150             ItemInfo info;
3151             info.startPos = clip->startPos() + offset;
3152             info.endPos = clip->endPos() + offset;
3153             info.cropStart = clip->cropStart();
3154             info.track = clip->track() + trackOffset;
3155             if (canBePastedTo(info, AVWIDGET)) {
3156                 new AddTimelineClipCommand(this, clip->xml(), clip->clipProducer(), info, clip->effectList(), true, false, pasteClips);
3157             } else emit displayMessage(i18n("Cannot paste clip to selected place"), ErrorMessage);
3158         } else if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == TRANSITIONWIDGET) {
3159             Transition *tr = static_cast <Transition *>(m_copiedItems.at(i));
3160             ItemInfo info;
3161             info.startPos = tr->startPos() + offset;
3162             info.endPos = tr->endPos() + offset;
3163             info.track = tr->track() + trackOffset;
3164             if (canBePastedTo(info, TRANSITIONWIDGET)) {
3165                 if (info.startPos >= info.endPos) {
3166                     emit displayMessage(i18n("Invalid transition"), ErrorMessage);
3167                 } else new AddTransitionCommand(this, info, tr->transitionEndTrack() + trackOffset, tr->toXML(), false, true, pasteClips);
3168             } else emit displayMessage(i18n("Cannot paste transition to selected place"), ErrorMessage);
3169         }
3170     }
3171     m_commandStack->push(pasteClips);
3172 }
3173
3174 void CustomTrackView::pasteClipEffects() {
3175     if (m_copiedItems.count() != 1 || m_copiedItems.at(0)->type() != AVWIDGET) {
3176         emit displayMessage(i18n("You must copy exactly one clip before pasting effects"), ErrorMessage);
3177         return;
3178     }
3179     ClipItem *clip = static_cast < ClipItem *>(m_copiedItems.at(0));
3180     EffectsList effects = clip->effectList();
3181
3182     QUndoCommand *paste = new QUndoCommand();
3183     paste->setText("Paste effects");
3184
3185     QList<QGraphicsItem *> clips = scene()->selectedItems();
3186     for (int i = 0; i < clips.count(); ++i) {
3187         if (clips.at(i)->type() == AVWIDGET) {
3188             ClipItem *item = static_cast < ClipItem *>(clips.at(i));
3189             for (int i = 0; i < clip->effectsCount(); i++) {
3190                 new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), clip->effectAt(i), true, paste);
3191             }
3192         }
3193     }
3194     m_commandStack->push(paste);
3195 }
3196
3197
3198 ClipItem *CustomTrackView::getClipUnderCursor() const {
3199     QRectF rect((double) m_cursorPos, 0.0, 1.0, (double)(m_tracksHeight * m_document->tracksCount()));
3200     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
3201     for (int i = 0; i < collisions.count(); i++) {
3202         if (collisions.at(i)->type() == AVWIDGET) {
3203             return static_cast < ClipItem *>(collisions.at(i));
3204         }
3205     }
3206     return NULL;
3207 }
3208
3209 ClipItem *CustomTrackView::getMainActiveClip() const {
3210     QList<QGraphicsItem *> clips = scene()->selectedItems();
3211     if (clips.isEmpty()) {
3212         return getClipUnderCursor();
3213     } else {
3214         ClipItem *item = NULL;
3215         for (int i = 0; i < clips.count(); ++i) {
3216             if (clips.at(i)->type() == AVWIDGET)
3217                 item = static_cast < ClipItem *>(clips.at(i));
3218             if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos) break;
3219         }
3220         if (item) return item;
3221     }
3222     return NULL;
3223 }
3224
3225 ClipItem *CustomTrackView::getActiveClipUnderCursor(bool allowOutsideCursor) const {
3226     QList<QGraphicsItem *> clips = scene()->selectedItems();
3227     if (clips.isEmpty()) {
3228         return getClipUnderCursor();
3229     } else {
3230         ClipItem *item;
3231         // remove all items in the list that are not clips
3232         for (int i = 0; i < clips.count();) {
3233             if (clips.at(i)->type() != AVWIDGET) clips.removeAt(i);
3234             else i++;
3235         }
3236         if (clips.count() == 1 && allowOutsideCursor) return static_cast < ClipItem *>(clips.at(0));
3237         for (int i = 0; i < clips.count(); ++i) {
3238             if (clips.at(i)->type() == AVWIDGET)
3239                 item = static_cast < ClipItem *>(clips.at(i));
3240             if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos) return item;
3241         }
3242     }
3243     return NULL;
3244 }
3245
3246 void CustomTrackView::setInPoint() {
3247     ClipItem *clip = getActiveClipUnderCursor(true);
3248     if (clip == NULL) {
3249         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
3250         return;
3251     }
3252     ItemInfo startInfo = clip->info();
3253     ItemInfo endInfo = clip->info();
3254     endInfo.startPos = GenTime(m_cursorPos, m_document->fps());
3255     if (endInfo.startPos >= startInfo.endPos) {
3256         // Check for invalid resize
3257         emit displayMessage(i18n("Invalid action"), ErrorMessage);
3258         return;
3259     } else if (endInfo.startPos < startInfo.startPos) {
3260         int length = m_document->renderer()->mltGetSpaceLength(endInfo.startPos, m_document->tracksCount() - startInfo.track, false);
3261         if (length < (startInfo.startPos - endInfo.startPos).frames(m_document->fps())) {
3262             emit displayMessage(i18n("Invalid action"), ErrorMessage);
3263             return;
3264         }
3265     }
3266     ResizeClipCommand *command = new ResizeClipCommand(this, startInfo, endInfo, true);
3267     m_commandStack->push(command);
3268 }
3269
3270 void CustomTrackView::setOutPoint() {
3271     ClipItem *clip = getActiveClipUnderCursor(true);
3272     if (clip == NULL) {
3273         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
3274         return;
3275     }
3276     ItemInfo startInfo = clip->info();
3277     ItemInfo endInfo = clip->info();
3278     endInfo.endPos = GenTime(m_cursorPos, m_document->fps());
3279     if (endInfo.endPos <= startInfo.startPos) {
3280         // Check for invalid resize
3281         emit displayMessage(i18n("Invalid action"), ErrorMessage);
3282         return;
3283     } else if (endInfo.endPos > startInfo.endPos) {
3284         int length = m_document->renderer()->mltGetSpaceLength(endInfo.endPos, m_document->tracksCount() - startInfo.track, false);
3285         if (length < (endInfo.endPos - startInfo.endPos).frames(m_document->fps())) {
3286             emit displayMessage(i18n("Invalid action"), ErrorMessage);
3287             return;
3288         }
3289     }
3290
3291
3292
3293     ResizeClipCommand *command = new ResizeClipCommand(this, startInfo, endInfo, true);
3294     m_commandStack->push(command);
3295 }
3296
3297 void CustomTrackView::slotUpdateAllThumbs() {
3298     QList<QGraphicsItem *> itemList = items();
3299     //if (itemList.isEmpty()) return;
3300     ClipItem *item;
3301     QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
3302     for (int i = 0; i < itemList.count(); i++) {
3303         if (itemList.at(i)->type() == AVWIDGET) {
3304             item = static_cast <ClipItem *>(itemList.at(i));
3305             if (item->clipType() != COLOR) {
3306                 // Check if we have a cached thumbnail
3307                 if (item->clipType() == IMAGE || item->clipType() == TEXT || item->clipType() == AUDIO) {
3308                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
3309                     if (QFile::exists(thumb)) {
3310                         QPixmap pix(thumb);
3311                         item->slotSetStartThumb(pix);
3312                         item->slotSetEndThumb(pix);
3313                     }
3314                 } else {
3315                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
3316                     QString endThumb = startThumb;
3317                     startThumb.append(QString::number(item->cropStart().frames(m_document->fps())) + ".png");
3318                     endThumb.append(QString::number((item->cropStart() + item->cropDuration()).frames(m_document->fps()) - 1) + ".png");
3319                     if (QFile::exists(startThumb)) {
3320                         QPixmap pix(startThumb);
3321                         item->slotSetStartThumb(pix);
3322                     }
3323                     if (QFile::exists(endThumb)) {
3324                         QPixmap pix(endThumb);
3325                         item->slotSetEndThumb(pix);
3326                     }
3327                 }
3328             }
3329             item->refreshClip();
3330             qApp->processEvents();
3331         }
3332     }
3333     viewport()->update();
3334 }
3335
3336 void CustomTrackView::saveThumbnails() {
3337     QList<QGraphicsItem *> itemList = items();
3338     ClipItem *item;
3339     QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
3340     for (int i = 0; i < itemList.count(); i++) {
3341         if (itemList.at(i)->type() == AVWIDGET) {
3342             item = static_cast <ClipItem *>(itemList.at(i));
3343             if (item->clipType() != COLOR) {
3344                 // Check if we have a cached thumbnail
3345                 if (item->clipType() == IMAGE || item->clipType() == TEXT || item->clipType() == AUDIO) {
3346                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
3347                     if (!QFile::exists(thumb)) {
3348                         QPixmap pix(item->startThumb());
3349                         pix.save(thumb);
3350                     }
3351                 } else {
3352                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
3353                     QString endThumb = startThumb;
3354                     startThumb.append(QString::number(item->cropStart().frames(m_document->fps())) + ".png");
3355                     endThumb.append(QString::number((item->cropStart() + item->cropDuration()).frames(m_document->fps()) - 1) + ".png");
3356                     if (!QFile::exists(startThumb)) {
3357                         QPixmap pix(item->startThumb());
3358                         pix.save(startThumb);
3359                     }
3360                     if (!QFile::exists(endThumb)) {
3361                         QPixmap pix(item->endThumb());
3362                         pix.save(endThumb);
3363                     }
3364                 }
3365             }
3366         }
3367     }
3368 }
3369
3370
3371 void CustomTrackView::slotInsertTrack(int ix) {
3372     kDebug() << "// INSERTING TRK: " << ix;
3373     QDialog d(parentWidget());
3374     Ui::AddTrack_UI view;
3375     view.setupUi(&d);
3376     view.track_nb->setMaximum(m_document->tracksCount() - 1);
3377     view.track_nb->setValue(ix);
3378     d.setWindowTitle(i18n("Insert Track"));
3379
3380     if (d.exec() == QDialog::Accepted) {
3381         ix = view.track_nb->value();
3382         if (view.before_select->currentIndex() == 1) {
3383             ix++;
3384         }
3385         TrackInfo info;
3386         if (view.video_track->isChecked()) {
3387             info.type = VIDEOTRACK;
3388             info.isMute = false;
3389             info.isBlind = false;
3390             info.isLocked = false;
3391         } else {
3392             info.type = AUDIOTRACK;
3393             info.isMute = false;
3394             info.isBlind = true;
3395             info.isLocked = false;
3396         }
3397         AddTrackCommand *addTrack = new AddTrackCommand(this, ix, info, true, true);
3398         m_commandStack->push(addTrack);
3399         m_document->setModified(true);
3400     }
3401 }
3402
3403 void CustomTrackView::slotDeleteTrack(int ix) {
3404     bool ok;
3405     ix = QInputDialog::getInteger(this, i18n("Remove Track"), i18n("Track"), ix, 0, m_document->tracksCount() - 1, 1, &ok);
3406     if (ok) {
3407         TrackInfo info = m_document->trackInfoAt(m_document->tracksCount() - ix - 1);
3408         deleteTimelineTrack(ix, info);
3409         m_document->setModified(true);
3410         /*AddTrackCommand* command = new AddTrackCommand(this, ix, info, false, true);
3411         m_commandStack->push(command);*/
3412     }
3413 }
3414
3415 void CustomTrackView::slotChangeTrack(int ix) {
3416     QDialog d(parentWidget());
3417     Ui::AddTrack_UI view;
3418     view.setupUi(&d);
3419     view.label->setText(i18n("Change track"));
3420     view.before_select->setHidden(true);
3421     view.track_nb->setMaximum(m_document->tracksCount() - 1);
3422     view.track_nb->setValue(ix);
3423     d.setWindowTitle(i18n("Change Track Type"));
3424
3425     if (d.exec() == QDialog::Accepted) {
3426         TrackInfo info;
3427         info.isLocked = false;
3428         info.isMute = false;
3429
3430         if (view.video_track->isChecked()) {
3431             info.type = VIDEOTRACK;
3432             info.isBlind = false;
3433         } else {
3434             info.type = AUDIOTRACK;
3435             info.isBlind = true;
3436         }
3437         changeTimelineTrack(ix, info);
3438         m_document->setModified(true);
3439     }
3440 }
3441
3442
3443 void CustomTrackView::deleteTimelineTrack(int ix, TrackInfo trackinfo) {
3444     double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
3445     QRectF r(0, startY, sceneRect().width(), m_tracksHeight / 2 - 1);
3446     QList<QGraphicsItem *> selection = m_scene->items(r);
3447     QUndoCommand *deleteTrack = new QUndoCommand();
3448     deleteTrack->setText("Delete track");
3449
3450     // Delete all clips in selected track
3451     for (int i = 0; i < selection.count(); i++) {
3452         if (selection.at(i)->type() == AVWIDGET) {
3453             ClipItem *item =  static_cast <ClipItem *>(selection.at(i));
3454             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, true, deleteTrack);
3455             m_scene->removeItem(item);
3456             delete item;
3457             item = NULL;
3458         } else if (selection.at(i)->type() == TRANSITIONWIDGET) {
3459             Transition *item =  static_cast <Transition *>(selection.at(i));
3460             new AddTransitionCommand(this, item->info(), item->transitionEndTrack(), item->toXML(), true, false, deleteTrack);
3461             m_scene->removeItem(item);
3462             delete item;
3463             item = NULL;
3464         }
3465     }
3466
3467     new AddTrackCommand(this, ix, trackinfo, false, true, deleteTrack);
3468     m_commandStack->push(deleteTrack);
3469 }
3470
3471 void CustomTrackView::changeTimelineTrack(int ix, TrackInfo trackinfo) {
3472     TrackInfo oldinfo = m_document->trackInfoAt(m_document->tracksCount() - ix);
3473     ChangeTrackCommand *changeTrack = new ChangeTrackCommand(this, ix, oldinfo, trackinfo, true);
3474     m_commandStack->push(changeTrack);
3475 }
3476
3477 void CustomTrackView::autoTransition() {
3478     QList<QGraphicsItem *> itemList = scene()->selectedItems();
3479     if (itemList.count() != 1 || itemList.at(0)->type() != TRANSITIONWIDGET) {
3480         emit displayMessage(i18n("You must select one transition for this action"), ErrorMessage);
3481         return;
3482     }
3483     Transition *tr = static_cast <Transition*>(itemList.at(0));
3484     tr->setAutomatic(!tr->isAutomatic());
3485     QDomElement transition = tr->toXML();
3486     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);
3487 }
3488
3489
3490 QStringList CustomTrackView::getLadspaParams(QDomElement effect) const {
3491     QStringList result;
3492     QDomNodeList params = effect.elementsByTagName("parameter");
3493     for (int i = 0; i < params.count(); i++) {
3494         QDomElement e = params.item(i).toElement();
3495         if (!e.isNull() && e.attribute("type") == "constant") {
3496             if (e.hasAttribute("factor")) {
3497                 double factor = e.attribute("factor").toDouble();
3498                 double value = e.attribute("value").toDouble();
3499                 value = value / factor;
3500                 result.append(QString::number(value));
3501             } else result.append(e.attribute("value"));
3502         }
3503     }
3504     return result;
3505 }
3506
3507 void CustomTrackView::clipNameChanged(const QString id, const QString name) {
3508     QList<QGraphicsItem *> list = scene()->items();
3509     ClipItem *clip = NULL;
3510     for (int i = 0; i < list.size(); ++i) {
3511         if (list.at(i)->type() == AVWIDGET) {
3512             clip = static_cast <ClipItem *>(list.at(i));
3513             if (clip->clipProducer() == id) {
3514                 clip->setClipName(name);
3515             }
3516         }
3517     }
3518     viewport()->update();
3519 }
3520
3521 #include "customtrackview.moc"