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