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