git.sesse.net Git - kdenlive/blob - src/customtrackview.cpp

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