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