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
  21 #include "customtrackview.h"
  22 #include "customtrackscene.h"
  23 #include "docclipbase.h"
  24 #include "clipitem.h"
  25 #include "definitions.h"
  26 #include "moveclipcommand.h"
  27 #include "movetransitioncommand.h"
  28 #include "resizeclipcommand.h"
  29 #include "editguidecommand.h"
  30 #include "addtimelineclipcommand.h"
  31 #include "addeffectcommand.h"
  32 #include "editeffectcommand.h"
  33 #include "moveeffectcommand.h"
  34 #include "addtransitioncommand.h"
  35 #include "edittransitioncommand.h"
  36 #include "editkeyframecommand.h"
  37 #include "changespeedcommand.h"
  38 #include "addmarkercommand.h"
  39 #include "razorclipcommand.h"
  40 #include "kdenlivesettings.h"
  41 #include "transition.h"
  42 #include "clipmanager.h"
  43 #include "renderer.h"
  44 #include "markerdialog.h"
  45 #include "mainwindow.h"
  46 #include "ui_keyframedialog_ui.h"
  47 #include "clipdurationdialog.h"
  48 #include "abstractgroupitem.h"
  49 #include "insertspacecommand.h"
  50 #include "spacerdialog.h"
  51 #include "addtrackcommand.h"
  52 #include "changetrackcommand.h"
  53 #include "movegroupcommand.h"
  54 #include "ui_addtrack_ui.h"
  55 #include "initeffects.h"
  56 #include "locktrackcommand.h"
  57 #include "groupclipscommand.h"
  58 #include "splitaudiocommand.h"
  59 #include "changecliptypecommand.h"
  60
  61 #include <KDebug>
  62 #include <KLocale>
  63 #include <KUrl>
  64 #include <KIcon>
  65 #include <KCursor>
  66 #include <KColorScheme>
  67
  68 #include <QMouseEvent>
  69 #include <QStylePainter>
  70 #include <QGraphicsItem>
  71 #include <QDomDocument>
  72 #include <QScrollBar>
  73 #include <QApplication>
  74 #include <QInputDialog>
  75
  76
  77 //TODO:
  78 // disable animation if user asked it in KDE's global settings
  79 // http://lists.kde.org/?l=kde-commits&m=120398724717624&w=2
  80 // needs something like below (taken from dolphin)
  81 // #include <kglobalsettings.h>
  82 // const bool animate = KGlobalSettings::graphicEffectsLevel() & KGlobalSettings::SimpleAnimationEffects;
  83 // const int duration = animate ? 1500 : 1;
  84
  85 CustomTrackView::CustomTrackView(KdenliveDoc *doc, CustomTrackScene* projectscene, QWidget *parent) :
  86         QGraphicsView(projectscene, parent),
  87         m_tracksHeight(KdenliveSettings::trackheight()),
  88         m_projectDuration(0),
  89         m_cursorPos(0),
  90         m_document(doc),
  91         m_scene(projectscene),
  92         m_cursorLine(NULL),
  93         m_operationMode(NONE),
  94         m_moveOpMode(NONE),
  95         m_dragItem(NULL),
  96         m_dragGuide(NULL),
  97         m_visualTip(NULL),
  98         m_animation(NULL),
  99         m_clickPoint(),
 100         m_autoScroll(KdenliveSettings::autoscroll()),
 101         m_changeSpeedAction(NULL),
 102         m_pasteEffectsAction(NULL),
 103         m_ungroupAction(NULL),
 104         m_scrollOffset(0),
 105         m_clipDrag(false),
 106         m_findIndex(0),
 107         m_tool(SELECTTOOL),
 108         m_copiedItems(),
 109         m_menuPosition(),
 110         m_blockRefresh(false),
 111         m_selectionGroup(NULL)
 112 {
 113     if (doc) m_commandStack = doc->commandStack();
 114     else m_commandStack = NULL;
 115     setMouseTracking(true);
 116     setAcceptDrops(true);
 117     KdenliveSettings::setTrackheight(m_tracksHeight);
 118     m_animationTimer = new QTimeLine(800);
 119     m_animationTimer->setFrameRange(0, 5);
 120     m_animationTimer->setUpdateInterval(100);
 121     m_animationTimer->setLoopCount(0);
 122     m_tipColor = QColor(0, 192, 0, 200);
 123     QColor border = QColor(255, 255, 255, 100);
 124     m_tipPen.setColor(border);
 125     m_tipPen.setWidth(3);
 126     setContentsMargins(0, 0, 0, 0);
 127     const int maxWidth = m_tracksHeight * m_document->tracksCount();
 128     setSceneRect(0, 0, sceneRect().width(), maxWidth);
 129     verticalScrollBar()->setMaximum(maxWidth);
 130     m_cursorLine = projectscene->addLine(0, 0, 0, maxWidth);
 131     m_cursorLine->setZValue(1000);
 132
 133     KIcon razorIcon("edit-cut");
 134     m_razorCursor = QCursor(razorIcon.pixmap(22, 22));
 135
 136     KIcon spacerIcon("kdenlive-spacer-tool");
 137     m_spacerCursor = QCursor(spacerIcon.pixmap(22, 22));
 138     verticalScrollBar()->setTracking(true);
 139     // Line below was supposed to scroll guides label with scrollbar, not implemented yet
 140     //connect(verticalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(slotRefreshGuides()));
 141     connect(&m_scrollTimer, SIGNAL(timeout()), this, SLOT(slotCheckMouseScrolling()));
 142     m_scrollTimer.setInterval(100);
 143     m_scrollTimer.setSingleShot(true);
 144
 145     connect(&m_thumbsTimer, SIGNAL(timeout()), this, SLOT(slotFetchNextThumbs()));
 146     m_thumbsTimer.setInterval(500);
 147     m_thumbsTimer.setSingleShot(true);
 148 }
 149
 150 CustomTrackView::~CustomTrackView()
 151 {
 152     qDeleteAll(m_guides);
 153     m_waitingThumbs.clear();
 154 }
 155
 156 void CustomTrackView::setDocumentModified()
 157 {
 158     m_document->setModified(true);
 159 }
 160
 161 void CustomTrackView::setContextMenu(QMenu *timeline, QMenu *clip, QMenu *transition, QActionGroup *clipTypeGroup)
 162 {
 163     m_timelineContextMenu = timeline;
 164     m_timelineContextClipMenu = clip;
 165     m_clipTypeGroup = clipTypeGroup;
 166     QList <QAction *> list = m_timelineContextClipMenu->actions();
 167     for (int i = 0; i < list.count(); i++) {
 168         if (list.at(i)->data().toString() == "change_speed") m_changeSpeedAction = list.at(i);
 169         else if (list.at(i)->data().toString() == "paste_effects") m_pasteEffectsAction = list.at(i);
 170         else if (list.at(i)->data().toString() == "ungroup_clip") m_ungroupAction = list.at(i);
 171     }
 172
 173     m_timelineContextTransitionMenu = transition;
 174     list = m_timelineContextTransitionMenu->actions();
 175     for (int i = 0; i < list.count(); i++) {
 176         if (list.at(i)->data().toString() == "auto") {
 177             m_autoTransition = list.at(i);
 178             break;
 179         }
 180     }
 181
 182     m_timelineContextMenu->addSeparator();
 183     m_deleteGuide = new KAction(KIcon("edit-delete"), i18n("Delete Guide"), this);
 184     connect(m_deleteGuide, SIGNAL(triggered()), this, SLOT(slotDeleteTimeLineGuide()));
 185     m_timelineContextMenu->addAction(m_deleteGuide);
 186
 187     m_editGuide = new KAction(KIcon("document-properties"), i18n("Edit Guide"), this);
 188     connect(m_editGuide, SIGNAL(triggered()), this, SLOT(slotEditTimeLineGuide()));
 189     m_timelineContextMenu->addAction(m_editGuide);
 190 }
 191
 192 void CustomTrackView::checkAutoScroll()
 193 {
 194     m_autoScroll = KdenliveSettings::autoscroll();
 195 }
 196
 197 /*sQList <TrackInfo> CustomTrackView::tracksList() const {
 198     return m_scene->m_tracksList;
 199 }*/
 200
 201 void CustomTrackView::checkTrackHeight()
 202 {
 203     if (m_tracksHeight == KdenliveSettings::trackheight()) return;
 204     m_tracksHeight = KdenliveSettings::trackheight();
 205     emit trackHeightChanged();
 206     QList<QGraphicsItem *> itemList = items();
 207     ClipItem *item;
 208     Transition *transitionitem;
 209     bool snap = KdenliveSettings::snaptopoints();
 210     KdenliveSettings::setSnaptopoints(false);
 211     for (int i = 0; i < itemList.count(); i++) {
 212         if (itemList.at(i)->type() == AVWIDGET) {
 213             item = (ClipItem*) itemList.at(i);
 214             item->setRect(0, 0, item->rect().width(), m_tracksHeight - 1);
 215             item->setPos((qreal) item->startPos().frames(m_document->fps()), (qreal) item->track() * m_tracksHeight + 1);
 216             item->resetThumbs(true);
 217         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
 218             transitionitem = (Transition*) itemList.at(i);
 219             transitionitem->setRect(0, 0, transitionitem->rect().width(), m_tracksHeight / 3 * 2 - 1);
 220             transitionitem->setPos((qreal) transitionitem->startPos().frames(m_document->fps()), (qreal) transitionitem->track() * m_tracksHeight + m_tracksHeight / 3 * 2);
 221         }
 222     }
 223     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), m_tracksHeight * m_document->tracksCount());
 224
 225     for (int i = 0; i < m_guides.count(); i++) {
 226         QLineF l = m_guides.at(i)->line();
 227         l.setP2(QPointF(l.x2(), m_tracksHeight * m_document->tracksCount()));
 228         m_guides.at(i)->setLine(l);
 229     }
 230
 231     setSceneRect(0, 0, sceneRect().width(), m_tracksHeight * m_document->tracksCount());
 232 //     verticalScrollBar()->setMaximum(m_tracksHeight * m_document->tracksCount());
 233     KdenliveSettings::setSnaptopoints(snap);
 234     viewport()->update();
 235 }
 236
 237 /** Zoom or move viewport on mousewheel
 238  *
 239  * If mousewheel+Ctrl, zooms in/out on the timeline.
 240  *
 241  * With Ctrl, moves viewport towards end of timeline if down/back,
 242  * opposite on up/forward.
 243  *
 244  * See also http://www.kdenlive.org/mantis/view.php?id=265 */
 245 void CustomTrackView::wheelEvent(QWheelEvent * e)
 246 {
 247     if (e->modifiers() == Qt::ControlModifier) {
 248         if (e->delta() > 0) emit zoomIn();
 249         else emit zoomOut();
 250     } else {
 251         if (e->delta() <= 0) horizontalScrollBar()->setValue(horizontalScrollBar()->value() + horizontalScrollBar()->singleStep());
 252         else  horizontalScrollBar()->setValue(horizontalScrollBar()->value() - horizontalScrollBar()->singleStep());
 253     }
 254 }
 255
 256 int CustomTrackView::getPreviousVideoTrack(int track)
 257 {
 258     track = m_document->tracksCount() - track - 1;
 259     track --;
 260     for (int i = track; i > -1; i--) {
 261         if (m_document->trackInfoAt(i).type == VIDEOTRACK) return i + 1;
 262     }
 263     return 0;
 264 }
 265
 266
 267 void CustomTrackView::slotFetchNextThumbs()
 268 {
 269     if (!m_waitingThumbs.isEmpty()) {
 270         ClipItem *item = m_waitingThumbs.takeFirst();
 271         while ((item == NULL) && !m_waitingThumbs.isEmpty()) {
 272             item = m_waitingThumbs.takeFirst();
 273         }
 274         if (item) item->slotFetchThumbs();
 275         if (!m_waitingThumbs.isEmpty()) m_thumbsTimer.start();
 276     }
 277 }
 278
 279 void CustomTrackView::slotCheckMouseScrolling()
 280 {
 281     if (m_scrollOffset == 0) {
 282         m_scrollTimer.stop();
 283         return;
 284     }
 285     horizontalScrollBar()->setValue(horizontalScrollBar()->value() + m_scrollOffset);
 286     m_scrollTimer.start();
 287 }
 288
 289 void CustomTrackView::slotCheckPositionScrolling()
 290 {
 291     // If mouse is at a border of the view, scroll
 292     if (m_moveOpMode != SEEK) return;
 293     if (mapFromScene(m_cursorPos, 0).x() < 3) {
 294         horizontalScrollBar()->setValue(horizontalScrollBar()->value() - 2);
 295         QTimer::singleShot(200, this, SLOT(slotCheckPositionScrolling()));
 296         setCursorPos(mapToScene(QPoint(-2, 0)).x());
 297     } else if (viewport()->width() - 3 < mapFromScene(m_cursorPos + 1, 0).x()) {
 298         horizontalScrollBar()->setValue(horizontalScrollBar()->value() + 2);
 299         setCursorPos(mapToScene(QPoint(viewport()->width(), 0)).x() + 1);
 300         QTimer::singleShot(200, this, SLOT(slotCheckPositionScrolling()));
 301     }
 302 }
 303
 304
 305 // virtual
 306
 307 void CustomTrackView::mouseMoveEvent(QMouseEvent * event)
 308 {
 309     int pos = event->x();
 310     int mappedXPos = (int)(mapToScene(event->pos()).x() + 0.5);
 311     emit mousePosition(mappedXPos);
 312
 313     if (event->buttons() & Qt::MidButton) return;
 314     if (m_operationMode == RUBBERSELECTION || (event->modifiers() == Qt::ControlModifier && m_tool != SPACERTOOL)) {
 315         QGraphicsView::mouseMoveEvent(event);
 316         m_moveOpMode = NONE;
 317         return;
 318     }
 319
 320     if (event->buttons() != Qt::NoButton) {
 321         bool move = (event->pos() - m_clickEvent).manhattanLength() >= QApplication::startDragDistance();
 322         if (m_dragItem && m_tool == SELECTTOOL) {
 323             if (m_operationMode == MOVE && move) {
 324                 QGraphicsView::mouseMoveEvent(event);
 325                 // If mouse is at a border of the view, scroll
 326                 if (pos < 5) {
 327                     m_scrollOffset = -30;
 328                     m_scrollTimer.start();
 329                 } else if (viewport()->width() - pos < 10) {
 330                     m_scrollOffset = 30;
 331                     m_scrollTimer.start();
 332                 } else if (m_scrollTimer.isActive()) m_scrollTimer.stop();
 333
 334             } else if (m_operationMode == RESIZESTART && move) {
 335                 double snappedPos = getSnapPointForPos(mappedXPos);
 336                 m_document->renderer()->pause();
 337                 m_dragItem->resizeStart((int)(snappedPos));
 338             } else if (m_operationMode == RESIZEEND && move) {
 339                 double snappedPos = getSnapPointForPos(mappedXPos);
 340                 m_document->renderer()->pause();
 341                 m_dragItem->resizeEnd((int)(snappedPos));
 342             } else if (m_operationMode == FADEIN && move) {
 343                 ((ClipItem*) m_dragItem)->setFadeIn((int)(mappedXPos - m_dragItem->startPos().frames(m_document->fps())));
 344             } else if (m_operationMode == FADEOUT && move) {
 345                 ((ClipItem*) m_dragItem)->setFadeOut((int)(m_dragItem->endPos().frames(m_document->fps()) - mappedXPos));
 346             } else if (m_operationMode == KEYFRAME && move) {
 347                 GenTime keyFramePos = GenTime(mappedXPos, m_document->fps()) - m_dragItem->startPos() + m_dragItem->cropStart();
 348                 double pos = mapToScene(event->pos()).toPoint().y();
 349                 QRectF br = m_dragItem->sceneBoundingRect();
 350                 double maxh = 100.0 / br.height();
 351                 pos = (br.bottom() - pos) * maxh;
 352                 m_dragItem->updateKeyFramePos(keyFramePos, pos);
 353             }
 354
 355             delete m_animation;
 356             m_animation = NULL;
 357             delete m_visualTip;
 358             m_visualTip = NULL;
 359             return;
 360         } else if (m_operationMode == MOVEGUIDE) {
 361             delete m_animation;
 362             m_animation = NULL;
 363             delete m_visualTip;
 364             m_visualTip = NULL;
 365             QGraphicsView::mouseMoveEvent(event);
 366             return;
 367         } else if (m_operationMode == SPACER && move && m_selectionGroup) {
 368             // spacer tool
 369             int mappedClick = (int)(mapToScene(m_clickEvent).x() + 0.5);
 370             m_selectionGroup->setPos(mappedXPos + (((int) m_selectionGroup->boundingRect().topLeft().x() + 0.5) - mappedClick) , m_selectionGroup->pos().y());
 371         }
 372     }
 373
 374     if (m_tool == RAZORTOOL) {
 375         setCursor(m_razorCursor);
 376         //QGraphicsView::mouseMoveEvent(event);
 377         //return;
 378     } else if (m_tool == SPACERTOOL) {
 379         setCursor(m_spacerCursor);
 380         return;
 381     }
 382
 383     QList<QGraphicsItem *> itemList = items(event->pos());
 384     QGraphicsRectItem *item = NULL;
 385     OPERATIONTYPE opMode = NONE;
 386
 387     if (itemList.count() == 1 && itemList.at(0)->type() == GUIDEITEM) {
 388         opMode = MOVEGUIDE;
 389     } else for (int i = 0; i < itemList.count(); i++) {
 390             if (itemList.at(i)->type() == AVWIDGET || itemList.at(i)->type() == TRANSITIONWIDGET) {
 391                 item = (QGraphicsRectItem*) itemList.at(i);
 392                 break;
 393             }
 394         }
 395
 396     if (item && event->buttons() == Qt::NoButton) {
 397         AbstractClipItem *clip = static_cast <AbstractClipItem*>(item);
 398         if (m_tool == RAZORTOOL) {
 399             // razor tool over a clip, display current frame in monitor
 400             if (!m_blockRefresh && item->type() == AVWIDGET) {
 401                 //TODO: solve crash when showing frame when moving razor over clip
 402                 //emit showClipFrame(((ClipItem *) item)->baseClip(), mappedXPos - (clip->startPos() - clip->cropStart()).frames(m_document->fps()));
 403             }
 404             event->accept();
 405             return;
 406         }
 407         opMode = clip->operationMode(mapToScene(event->pos()));
 408         const double size = 5;
 409         if (opMode == m_moveOpMode) {
 410             QGraphicsView::mouseMoveEvent(event);
 411             return;
 412         } else {
 413             if (m_visualTip) {
 414                 delete m_animation;
 415                 m_animation = NULL;
 416                 m_animationTimer->stop();
 417                 delete m_visualTip;
 418                 m_visualTip = NULL;
 419             }
 420         }
 421         m_moveOpMode = opMode;
 422         if (opMode == MOVE) {
 423             setCursor(Qt::OpenHandCursor);
 424         } else if (opMode == RESIZESTART) {
 425             setCursor(KCursor("left_side", Qt::SizeHorCursor));
 426             if (m_visualTip == NULL) {
 427                 QRectF rect = clip->sceneBoundingRect();
 428                 QPolygon polygon;
 429                 polygon << QPoint(0, - size * 2);
 430                 polygon << QPoint(size * 2, 0);
 431                 polygon << QPoint(0, size * 2);
 432                 polygon << QPoint(0, - size * 2);
 433
 434                 m_visualTip = new QGraphicsPolygonItem(polygon);
 435                 ((QGraphicsPolygonItem*) m_visualTip)->setBrush(m_tipColor);
 436                 ((QGraphicsPolygonItem*) m_visualTip)->setPen(m_tipPen);
 437                 m_visualTip->setPos(rect.x(), rect.y() + rect.height() / 2);
 438                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 439                 m_visualTip->setZValue(100);
 440                 m_animation = new QGraphicsItemAnimation;
 441                 m_animation->setItem(m_visualTip);
 442                 m_animation->setTimeLine(m_animationTimer);
 443                 m_animation->setScaleAt(.5, 2, 1);
 444                 m_animation->setScaleAt(1, 1, 1);
 445                 scene()->addItem(m_visualTip);
 446                 m_animationTimer->start();
 447             }
 448         } else if (opMode == RESIZEEND) {
 449             setCursor(KCursor("right_side", Qt::SizeHorCursor));
 450             if (m_visualTip == NULL) {
 451                 QRectF rect = clip->sceneBoundingRect();
 452                 QPolygon polygon;
 453                 polygon << QPoint(0, - size * 2);
 454                 polygon << QPoint(- size * 2, 0);
 455                 polygon << QPoint(0, size * 2);
 456                 polygon << QPoint(0, - size * 2);
 457
 458                 m_visualTip = new QGraphicsPolygonItem(polygon);
 459                 ((QGraphicsPolygonItem*) m_visualTip)->setBrush(m_tipColor);
 460                 ((QGraphicsPolygonItem*) m_visualTip)->setPen(m_tipPen);
 461                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 462                 m_visualTip->setPos(rect.right(), rect.y() + rect.height() / 2);
 463                 m_visualTip->setZValue(100);
 464                 m_animation = new QGraphicsItemAnimation;
 465                 m_animation->setItem(m_visualTip);
 466                 m_animation->setTimeLine(m_animationTimer);
 467                 m_animation->setScaleAt(.5, 2, 1);
 468                 m_animation->setScaleAt(1, 1, 1);
 469                 scene()->addItem(m_visualTip);
 470                 m_animationTimer->start();
 471             }
 472         } else if (opMode == FADEIN) {
 473             if (m_visualTip == NULL) {
 474                 ClipItem *item = (ClipItem *) clip;
 475                 QRectF rect = clip->sceneBoundingRect();
 476                 m_visualTip = new QGraphicsEllipseItem(-size, -size, size * 2, size * 2);
 477                 ((QGraphicsEllipseItem*) m_visualTip)->setBrush(m_tipColor);
 478                 ((QGraphicsEllipseItem*) m_visualTip)->setPen(m_tipPen);
 479                 m_visualTip->setPos(rect.x() + item->fadeIn(), rect.y());
 480                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 481                 m_visualTip->setZValue(100);
 482                 m_animation = new QGraphicsItemAnimation;
 483                 m_animation->setItem(m_visualTip);
 484                 m_animation->setTimeLine(m_animationTimer);
 485                 m_animation->setScaleAt(.5, 2, 2);
 486                 m_animation->setScaleAt(1, 1, 1);
 487                 scene()->addItem(m_visualTip);
 488                 m_animationTimer->start();
 489             }
 490             setCursor(Qt::PointingHandCursor);
 491         } else if (opMode == FADEOUT) {
 492             if (m_visualTip == NULL) {
 493                 ClipItem *item = (ClipItem *) clip;
 494                 QRectF rect = clip->sceneBoundingRect();
 495                 m_visualTip = new QGraphicsEllipseItem(-size, -size, size * 2, size * 2);
 496                 ((QGraphicsEllipseItem*) m_visualTip)->setBrush(m_tipColor);
 497                 ((QGraphicsEllipseItem*) m_visualTip)->setPen(m_tipPen);
 498                 m_visualTip->setPos(rect.right() - item->fadeOut(), rect.y());
 499                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 500                 m_visualTip->setZValue(100);
 501                 m_animation = new QGraphicsItemAnimation;
 502                 m_animation->setItem(m_visualTip);
 503                 m_animation->setTimeLine(m_animationTimer);
 504                 m_animation->setScaleAt(.5, 2, 2);
 505                 m_animation->setScaleAt(1, 1, 1);
 506                 scene()->addItem(m_visualTip);
 507                 m_animationTimer->start();
 508             }
 509             setCursor(Qt::PointingHandCursor);
 510         } else if (opMode == TRANSITIONSTART) {
 511             if (m_visualTip == NULL) {
 512                 QRectF rect = clip->sceneBoundingRect();
 513                 QPolygon polygon;
 514                 polygon << QPoint(0, - size * 2);
 515                 polygon << QPoint(size * 2, 0);
 516                 polygon << QPoint(0, 0);
 517                 polygon << QPoint(0, - size * 2);
 518
 519                 m_visualTip = new QGraphicsPolygonItem(polygon);
 520                 ((QGraphicsPolygonItem*) m_visualTip)->setBrush(m_tipColor);
 521                 ((QGraphicsPolygonItem*) m_visualTip)->setPen(m_tipPen);
 522                 m_visualTip->setPos(rect.x(), rect.bottom());
 523                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 524                 m_visualTip->setZValue(100);
 525                 m_animation = new QGraphicsItemAnimation;
 526                 m_animation->setItem(m_visualTip);
 527                 m_animation->setTimeLine(m_animationTimer);
 528                 m_animation->setScaleAt(.5, 2, 2);
 529                 m_animation->setScaleAt(1, 1, 1);
 530                 scene()->addItem(m_visualTip);
 531                 m_animationTimer->start();
 532             }
 533             setCursor(Qt::PointingHandCursor);
 534         } else if (opMode == TRANSITIONEND) {
 535             if (m_visualTip == NULL) {
 536                 QRectF rect = clip->sceneBoundingRect();
 537                 QPolygon polygon;
 538                 polygon << QPoint(0, - size * 2);
 539                 polygon << QPoint(- size * 2, 0);
 540                 polygon << QPoint(0, 0);
 541                 polygon << QPoint(0, - size * 2);
 542
 543                 m_visualTip = new QGraphicsPolygonItem(polygon);
 544                 ((QGraphicsPolygonItem*) m_visualTip)->setBrush(m_tipColor);
 545                 ((QGraphicsPolygonItem*) m_visualTip)->setPen(m_tipPen);
 546                 m_visualTip->setPos(rect.right(), rect.bottom());
 547                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 548                 m_visualTip->setZValue(100);
 549                 m_animation = new QGraphicsItemAnimation;
 550                 m_animation->setItem(m_visualTip);
 551                 m_animation->setTimeLine(m_animationTimer);
 552                 m_animation->setScaleAt(.5, 2, 2);
 553                 m_animation->setScaleAt(1, 1, 1);
 554                 scene()->addItem(m_visualTip);
 555                 m_animationTimer->start();
 556             }
 557             setCursor(Qt::PointingHandCursor);
 558         } else if (opMode == KEYFRAME) {
 559             setCursor(Qt::PointingHandCursor);
 560         }
 561     } // no clip under mouse
 562     else if (m_tool == RAZORTOOL) {
 563         event->accept();
 564         return;
 565     } else if (opMode == MOVEGUIDE) {
 566         m_moveOpMode = opMode;
 567         setCursor(Qt::SplitHCursor);
 568     } else {
 569         if (m_visualTip) {
 570             delete m_animation;
 571             m_animationTimer->stop();
 572             m_animation = NULL;
 573             delete m_visualTip;
 574             m_visualTip = NULL;
 575
 576         }
 577         setCursor(Qt::ArrowCursor);
 578         if (event->buttons() != Qt::NoButton && event->modifiers() == Qt::NoModifier) {
 579             QGraphicsView::mouseMoveEvent(event);
 580             m_moveOpMode = SEEK;
 581             setCursorPos(mappedXPos);
 582             slotCheckPositionScrolling();
 583             return;
 584         } else m_moveOpMode = NONE;
 585     }
 586     QGraphicsView::mouseMoveEvent(event);
 587 }
 588
 589 // virtual
 590 void CustomTrackView::mousePressEvent(QMouseEvent * event)
 591 {
 592     //kDebug() << "mousePressEvent STARTED";
 593     setFocus(Qt::MouseFocusReason);
 594     m_menuPosition = QPoint();
 595
 596     // special cases (middle click button or ctrl / shift click
 597     if (event->button() == Qt::MidButton) {
 598         m_document->renderer()->switchPlay();
 599         m_blockRefresh = false;
 600         m_operationMode = NONE;
 601         return;
 602     }
 603
 604     if (event->modifiers() & Qt::ShiftModifier) {
 605         setDragMode(QGraphicsView::RubberBandDrag);
 606         if (!(event->modifiers() & Qt::ControlModifier)) {
 607             resetSelectionGroup();
 608             scene()->clearSelection();
 609         }
 610         QGraphicsView::mousePressEvent(event);
 611         m_blockRefresh = false;
 612         m_operationMode = RUBBERSELECTION;
 613         return;
 614     }
 615
 616     m_blockRefresh = true;
 617     m_dragItem = NULL;
 618     m_dragGuide = NULL;
 619     bool collision = false;
 620
 621     if (m_tool != RAZORTOOL) activateMonitor();
 622     else if (m_document->renderer()->playSpeed() != 0.0) {
 623         m_document->renderer()->pause();
 624         return;
 625     }
 626     m_clickEvent = event->pos();
 627
 628     // check item under mouse
 629     QList<QGraphicsItem *> collisionList = items(m_clickEvent);
 630
 631     if (event->modifiers() == Qt::ControlModifier && m_tool != SPACERTOOL && collisionList.count() == 0) {
 632         setDragMode(QGraphicsView::ScrollHandDrag);
 633         QGraphicsView::mousePressEvent(event);
 634         m_blockRefresh = false;
 635         m_operationMode = NONE;
 636         return;
 637     }
 638
 639     // if a guide and a clip were pressed, just select the guide
 640     for (int i = 0; i < collisionList.count(); ++i) {
 641         if (collisionList.at(i)->type() == GUIDEITEM) {
 642             // a guide item was pressed
 643             m_dragGuide = (Guide *) collisionList.at(i);
 644             if (event->button() == Qt::LeftButton) { // move it
 645                 m_dragGuide->setFlag(QGraphicsItem::ItemIsMovable, true);
 646                 collision = true;
 647                 m_operationMode = MOVEGUIDE;
 648                 // deselect all clips so that only the guide will move
 649                 m_scene->clearSelection();
 650                 resetSelectionGroup(false);
 651                 updateSnapPoints(NULL);
 652                 QGraphicsView::mousePressEvent(event);
 653                 return;
 654             } else // show context menu
 655                 break;
 656         }
 657     }
 658
 659     // Find first clip, transition or group under mouse (when no guides selected)
 660     int ct = 0;
 661     AbstractGroupItem *dragGroup = NULL;
 662     while (!m_dragGuide && ct < collisionList.count()) {
 663         if (collisionList.at(ct)->type() == AVWIDGET || collisionList.at(ct)->type() == TRANSITIONWIDGET) {
 664             m_dragItem = static_cast <AbstractClipItem *>(collisionList.at(ct));
 665             m_dragItemInfo = m_dragItem->info();
 666             if (m_dragItem->parentItem() && m_dragItem->parentItem()->type() == GROUPWIDGET && m_dragItem->parentItem() != m_selectionGroup) {
 667                 // kDebug()<<"// KLIK FOUND GRP: "<<m_dragItem->sceneBoundingRect();
 668                 dragGroup = static_cast <AbstractGroupItem *>(m_dragItem->parentItem());
 669             }
 670             break;
 671         }
 672         ct++;
 673     }
 674
 675     if (m_dragItem && m_dragItem->type() == TRANSITIONWIDGET) {
 676         // update transition menu action
 677         m_autoTransition->setChecked(static_cast<Transition *>(m_dragItem)->isAutomatic());
 678         m_autoTransition->setEnabled(true);
 679     } else m_autoTransition->setEnabled(false);
 680
 681     // context menu requested
 682     if (event->button() == Qt::RightButton) {
 683         if (m_dragItem) {
 684             if (dragGroup) dragGroup->setSelected(true);
 685             else if (!m_dragItem->isSelected()) {
 686                 resetSelectionGroup(false);
 687                 m_scene->clearSelection();
 688                 m_dragItem->setSelected(true);
 689             }
 690         } else if (!m_dragGuide) {
 691             // check if there is a guide close to mouse click
 692             QList<QGraphicsItem *> guidesCollisionList = items(event->pos().x() - 5, event->pos().y(), 10, 2); // a rect of height < 2 does not always collide with the guide
 693             for (int i = 0; i < guidesCollisionList.count(); i++) {
 694                 if (guidesCollisionList.at(i)->type() == GUIDEITEM) {
 695                     m_dragGuide = static_cast <Guide *>(guidesCollisionList.at(i));
 696                     break;
 697                 }
 698             }
 699             // keep this to support multiple guides context menu in the future (?)
 700             /*if (guidesCollisionList.at(0)->type() != GUIDEITEM)
 701                 guidesCollisionList.removeAt(0);
 702             }
 703             if (!guidesCollisionList.isEmpty())
 704             m_dragGuide = static_cast <Guide *>(guidesCollisionList.at(0));*/
 705         }
 706
 707         m_operationMode = NONE;
 708         displayContextMenu(event->globalPos(), m_dragItem, dragGroup);
 709         m_menuPosition = m_clickEvent;
 710         m_dragItem = NULL;
 711         event->accept();
 712         return;
 713     }
 714
 715     // No item under click
 716     if (m_dragItem == NULL || m_tool == SPACERTOOL) {
 717         resetSelectionGroup(false);
 718         setCursor(Qt::ArrowCursor);
 719         m_scene->clearSelection();
 720         //event->accept();
 721         emit clipItemSelected(NULL);
 722         updateClipTypeActions(NULL);
 723         if (m_tool == SPACERTOOL) {
 724             QList<QGraphicsItem *> selection;
 725             if (event->modifiers() == Qt::ControlModifier) {
 726                 // Ctrl + click, select all items on track after click position
 727                 int track = (int)(mapToScene(m_clickEvent).y() / m_tracksHeight);
 728                 selection = items(m_clickEvent.x(), track * m_tracksHeight + m_tracksHeight / 2, mapFromScene(sceneRect().width(), 0).x() - m_clickEvent.x(), m_tracksHeight / 2 - 2);
 729
 730                 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;
 731             } else {
 732                 // Select all items on all tracks after click position
 733                 selection = items(event->pos().x(), 1, mapFromScene(sceneRect().width(), 0).x() - event->pos().x(), sceneRect().height());
 734                 kDebug() << "SELELCTING ELEMENTS WITHIN =" << event->pos().x() << "/" <<  1 << ", " << mapFromScene(sceneRect().width(), 0).x() - event->pos().x() << "/" << sceneRect().height();
 735             }
 736
 737             for (int i = 0; i < selection.count(); i++) {
 738                 if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET || selection.at(i)->type() == GROUPWIDGET) {
 739                     selection.at(i)->setSelected(true);
 740                 }
 741             }
 742             groupSelectedItems(true);
 743             m_operationMode = SPACER;
 744         } else setCursorPos((int)(mapToScene(event->x(), 0).x()));
 745         QGraphicsView::mousePressEvent(event);
 746         kDebug() << "END mousePress EVENT ";
 747         return;
 748     }
 749
 750     // Razor tool
 751     if (m_tool == RAZORTOOL && m_dragItem) {
 752         if (m_dragItem->type() == TRANSITIONWIDGET) {
 753             emit displayMessage(i18n("Cannot cut a transition"), ErrorMessage);
 754             event->accept();
 755             m_dragItem = NULL;
 756             return;
 757         } else if (m_dragItem->parentItem() && m_dragItem->parentItem() != m_selectionGroup) {
 758             emit displayMessage(i18n("Cannot cut a clip in a group"), ErrorMessage);
 759             event->accept();
 760             m_dragItem = NULL;
 761             return;
 762         }
 763         AbstractClipItem *clip = static_cast <AbstractClipItem *>(m_dragItem);
 764         RazorClipCommand* command = new RazorClipCommand(this, clip->info(), GenTime((int)(mapToScene(event->pos()).x()), m_document->fps()));
 765         m_document->renderer()->pause();
 766         m_commandStack->push(command);
 767         setDocumentModified();
 768         m_dragItem = NULL;
 769         event->accept();
 770         return;
 771     }
 772
 773     if (dragGroup == NULL) updateSnapPoints(m_dragItem);
 774     else {
 775         QList <GenTime> offsetList;
 776         QList<QGraphicsItem *> children = dragGroup->childItems();
 777         for (int i = 0; i < children.count(); i++) {
 778             if (children.at(i)->type() == AVWIDGET || children.at(i)->type() == TRANSITIONWIDGET) {
 779                 AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
 780                 offsetList.append(item->startPos());
 781                 offsetList.append(item->endPos());
 782             }
 783         }
 784         if (!offsetList.isEmpty()) {
 785             qSort(offsetList);
 786             GenTime startOffset = offsetList.takeFirst();
 787             QList <GenTime> cleandOffsetList;
 788             for (int k = 0; k < offsetList.size(); k++) {
 789                 GenTime newoffset = offsetList.at(k) - startOffset;
 790                 if (newoffset != GenTime() && !cleandOffsetList.contains(newoffset)) {
 791                     cleandOffsetList.append(newoffset);
 792                 }
 793             }
 794             updateSnapPoints(NULL, cleandOffsetList, true);
 795         }
 796     }
 797
 798     if (m_dragItem->type() == AVWIDGET && !m_dragItem->isItemLocked()) emit clipItemSelected((ClipItem*) m_dragItem);
 799     else emit clipItemSelected(NULL);
 800
 801     bool itemSelected = false;
 802     if (m_dragItem->isSelected()) itemSelected = true;
 803     else if (m_dragItem->parentItem() && m_dragItem->parentItem()->isSelected()) itemSelected = true;
 804     else if (dragGroup && dragGroup->isSelected()) itemSelected = true;
 805     if (event->modifiers() == Qt::ControlModifier || itemSelected == false) {
 806         resetSelectionGroup();
 807         if (event->modifiers() != Qt::ControlModifier) m_scene->clearSelection();
 808         dragGroup = NULL;
 809         if (m_dragItem->parentItem() && m_dragItem->parentItem()->type() == GROUPWIDGET) {
 810             //kDebug()<<"// KLIK FOUND GRP: "<<m_dragItem->sceneBoundingRect();
 811             dragGroup = static_cast <AbstractGroupItem *>(m_dragItem->parentItem());
 812         }
 813         bool selected = !m_dragItem->isSelected();
 814         if (dragGroup) dragGroup->setSelected(selected);
 815         else m_dragItem->setSelected(selected);
 816
 817         groupSelectedItems();
 818         ClipItem *clip = static_cast <ClipItem *>(m_dragItem);
 819         updateClipTypeActions(dragGroup == NULL ? clip : NULL);
 820         m_changeSpeedAction->setEnabled(clip->clipType() == AV || clip->clipType() == VIDEO);
 821         m_pasteEffectsAction->setEnabled(m_copiedItems.count() == 1);
 822     }
 823
 824     // If clicked item is selected, allow move
 825     if (event->modifiers() != Qt::ControlModifier && m_operationMode == NONE/* && (m_dragItem->isSelected() || (dragGroup && dragGroup->isSelected()))*/) QGraphicsView::mousePressEvent(event);
 826
 827     m_clickPoint = QPoint((int)(mapToScene(event->pos()).x() - m_dragItem->startPos().frames(m_document->fps())), (int)(event->pos().y() - m_dragItem->pos().y()));
 828     m_operationMode = m_dragItem->operationMode(mapToScene(event->pos()));
 829
 830     if (m_operationMode == KEYFRAME) {
 831         m_dragItem->updateSelectedKeyFrame();
 832         m_blockRefresh = false;
 833         return;
 834     } else if (m_operationMode == MOVE) {
 835         setCursor(Qt::ClosedHandCursor);
 836     } else if (m_operationMode == TRANSITIONSTART && event->modifiers() != Qt::ControlModifier) {
 837         ItemInfo info;
 838         info.startPos = m_dragItem->startPos();
 839         info.track = m_dragItem->track();
 840         int transitiontrack = getPreviousVideoTrack(info.track);
 841         ClipItem *transitionClip = NULL;
 842         if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.startPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
 843         if (transitionClip && transitionClip->endPos() < m_dragItem->endPos()) {
 844             info.endPos = transitionClip->endPos();
 845         } else info.endPos = info.startPos + GenTime(65, m_document->fps());
 846         if (info.endPos == info.startPos) info.endPos = info.startPos + GenTime(65, m_document->fps());
 847         // Check there is no other transition at that place
 848         double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
 849         QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
 850         QList<QGraphicsItem *> selection = m_scene->items(r);
 851         bool transitionAccepted = true;
 852         for (int i = 0; i < selection.count(); i++) {
 853             if (selection.at(i)->type() == TRANSITIONWIDGET) {
 854                 Transition *tr = static_cast <Transition *>(selection.at(i));
 855                 if (tr->startPos() - info.startPos > GenTime(5, m_document->fps())) {
 856                     if (tr->startPos() < info.endPos) info.endPos = tr->startPos();
 857                 } else transitionAccepted = false;
 858             }
 859         }
 860         if (transitionAccepted) slotAddTransition((ClipItem *) m_dragItem, info, transitiontrack);
 861         else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
 862     } else if (m_operationMode == TRANSITIONEND && event->modifiers() != Qt::ControlModifier) {
 863         ItemInfo info;
 864         info.endPos = GenTime(m_dragItem->endPos().frames(m_document->fps()), m_document->fps());
 865         info.track = m_dragItem->track();
 866         int transitiontrack = getPreviousVideoTrack(info.track);
 867         ClipItem *transitionClip = NULL;
 868         if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.endPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
 869         if (transitionClip && transitionClip->startPos() > m_dragItem->startPos()) {
 870             info.startPos = transitionClip->startPos();
 871         } else info.startPos = info.endPos - GenTime(65, m_document->fps());
 872         if (info.endPos == info.startPos) info.startPos = info.endPos - GenTime(65, m_document->fps());
 873         QDomElement transition = MainWindow::transitions.getEffectByTag("luma", "dissolve").cloneNode().toElement();
 874         EffectsList::setParameter(transition, "reverse", "1");
 875
 876         // Check there is no other transition at that place
 877         double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
 878         QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
 879         QList<QGraphicsItem *> selection = m_scene->items(r);
 880         bool transitionAccepted = true;
 881         for (int i = 0; i < selection.count(); i++) {
 882             if (selection.at(i)->type() == TRANSITIONWIDGET) {
 883                 Transition *tr = static_cast <Transition *>(selection.at(i));
 884                 if (info.endPos - tr->endPos() > GenTime(5, m_document->fps())) {
 885                     if (tr->endPos() > info.startPos) info.startPos = tr->endPos();
 886                 } else transitionAccepted = false;
 887             }
 888         }
 889         if (transitionAccepted) slotAddTransition((ClipItem *) m_dragItem, info, transitiontrack, transition);
 890         else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
 891
 892     } else if ((m_operationMode == RESIZESTART || m_operationMode == RESIZEEND) && m_selectionGroup) {
 893         resetSelectionGroup(false);
 894         m_dragItem->setSelected(true);
 895     }
 896
 897     m_blockRefresh = false;
 898     //kDebug()<<pos;
 899     //QGraphicsView::mousePressEvent(event);
 900 }
 901
 902 void CustomTrackView::resetSelectionGroup(bool selectItems)
 903 {
 904     if (m_selectionGroup) {
 905         // delete selection group
 906         bool snap = KdenliveSettings::snaptopoints();
 907         KdenliveSettings::setSnaptopoints(false);
 908
 909         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
 910         scene()->destroyItemGroup(m_selectionGroup);
 911         for (int i = 0; i < children.count(); i++) {
 912             if (children.at(i)->type() == AVWIDGET || children.at(i)->type() == TRANSITIONWIDGET) {
 913                 if (!static_cast <AbstractClipItem *>(children.at(i))->isItemLocked()) {
 914                     children.at(i)->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
 915                     children.at(i)->setSelected(selectItems);
 916                 }
 917             } else if (children.at(i)->type() == GROUPWIDGET) {
 918                 children.at(i)->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
 919                 children.at(i)->setSelected(selectItems);
 920             }
 921         }
 922         m_selectionGroup = NULL;
 923         KdenliveSettings::setSnaptopoints(snap);
 924     }
 925 }
 926
 927 void CustomTrackView::groupSelectedItems(bool force, bool createNewGroup)
 928 {
 929     if (m_selectionGroup) {
 930         kDebug() << "///// ERROR, TRYING TO OVERRIDE EXISTING GROUP";
 931         return;
 932     }
 933     QList<QGraphicsItem *> selection = m_scene->selectedItems();
 934     if (selection.isEmpty()) return;
 935     QPointF top = selection.at(0)->sceneBoundingRect().topLeft();
 936     // Find top left position of selection
 937     for (int i = 1; i < selection.count(); i++) {
 938         if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET || selection.at(i)->type() == GROUPWIDGET) {
 939             QPointF currenttop = selection.at(i)->sceneBoundingRect().topLeft();
 940             if (currenttop.x() < top.x()) top.setX(currenttop.x());
 941             if (currenttop.y() < top.y()) top.setY(currenttop.y());
 942         }
 943     }
 944
 945     if (force || selection.count() > 1) {
 946         bool snap = KdenliveSettings::snaptopoints();
 947         KdenliveSettings::setSnaptopoints(false);
 948         if (createNewGroup) {
 949             AbstractGroupItem *newGroup = m_document->clipManager()->createGroup();
 950             newGroup->translate(-top.x(), -top.y() + 1);
 951             newGroup->setPos(top.x(), top.y() - 1);
 952             scene()->addItem(newGroup);
 953
 954             // CHeck if we are trying to include a group in a group
 955             QList <AbstractGroupItem *> groups;
 956             for (int i = 0; i < selection.count(); i++) {
 957                 if (selection.at(i)->type() == GROUPWIDGET && !groups.contains(static_cast<AbstractGroupItem *>(selection.at(i)))) {
 958                     groups.append(static_cast<AbstractGroupItem *>(selection.at(i)));
 959                 } else if (selection.at(i)->parentItem() && !groups.contains(static_cast<AbstractGroupItem *>(selection.at(i)->parentItem()))) groups.append(static_cast<AbstractGroupItem *>(selection.at(i)->parentItem()));
 960             }
 961             if (!groups.isEmpty()) {
 962                 // ungroup previous groups
 963                 while (!groups.isEmpty()) {
 964                     AbstractGroupItem *grp = groups.takeFirst();
 965                     m_document->clipManager()->removeGroup(grp);
 966                     scene()->destroyItemGroup(grp);
 967                 }
 968                 selection = m_scene->selectedItems();
 969             }
 970
 971             for (int i = 0; i < selection.count(); i++) {
 972                 if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET) {
 973                     newGroup->addToGroup(selection.at(i));
 974                     selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
 975                 }
 976             }
 977             KdenliveSettings::setSnaptopoints(snap);
 978         } else {
 979             m_selectionGroup = new AbstractGroupItem(m_document->fps());
 980             m_selectionGroup->translate(-top.x(), -top.y() + 1);
 981             m_selectionGroup->setPos(top.x(), top.y() - 1);
 982             scene()->addItem(m_selectionGroup);
 983             for (int i = 0; i < selection.count(); i++) {
 984                 if (selection.at(i)->parentItem() == NULL && (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET || selection.at(i)->type() == GROUPWIDGET)) {
 985                     m_selectionGroup->addToGroup(selection.at(i));
 986                     selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
 987                 }
 988             }
 989             KdenliveSettings::setSnaptopoints(snap);
 990             if (m_selectionGroup) {
 991                 m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
 992                 m_selectionGroupInfo.track = m_selectionGroup->track();
 993             }
 994         }
 995     } else resetSelectionGroup();
 996 }
 997
 998 void CustomTrackView::mouseDoubleClickEvent(QMouseEvent *event)
 999 {
1000     kDebug() << "++++++++++++ DBL CLK";
1001     if (m_dragItem && m_dragItem->hasKeyFrames()) {
1002         if (m_moveOpMode == KEYFRAME) {
1003             // user double clicked on a keyframe, open edit dialog
1004             QDialog d(parentWidget());
1005             Ui::KeyFrameDialog_UI view;
1006             view.setupUi(&d);
1007             view.kfr_position->setText(m_document->timecode().getTimecode(GenTime(m_dragItem->selectedKeyFramePos(), m_document->fps()) - m_dragItem->cropStart(), m_document->fps()));
1008             view.kfr_value->setValue(m_dragItem->selectedKeyFrameValue());
1009             view.kfr_value->setFocus();
1010             if (d.exec() == QDialog::Accepted) {
1011                 int pos = m_document->timecode().getFrameCount(view.kfr_position->text(), m_document->fps());
1012                 m_dragItem->updateKeyFramePos(GenTime(pos, m_document->fps()) + m_dragItem->cropStart(), (double) view.kfr_value->value() * m_dragItem->keyFrameFactor());
1013                 ClipItem *item = (ClipItem *)m_dragItem;
1014                 QString previous = item->keyframes(item->selectedEffectIndex());
1015                 item->updateKeyframeEffect();
1016                 QString next = item->keyframes(item->selectedEffectIndex());
1017                 EditKeyFrameCommand *command = new EditKeyFrameCommand(this, item->track(), item->startPos(), item->selectedEffectIndex(), previous, next, false);
1018                 m_commandStack->push(command);
1019                 updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
1020                 emit clipItemSelected(item, item->selectedEffectIndex());
1021             }
1022
1023         } else  {
1024             // add keyframe
1025             GenTime keyFramePos = GenTime((int)(mapToScene(event->pos()).x()), m_document->fps()) - m_dragItem->startPos() + m_dragItem->cropStart();
1026             m_dragItem->addKeyFrame(keyFramePos, mapToScene(event->pos()).toPoint().y());
1027             ClipItem * item = (ClipItem *) m_dragItem;
1028             QString previous = item->keyframes(item->selectedEffectIndex());
1029             item->updateKeyframeEffect();
1030             QString next = item->keyframes(item->selectedEffectIndex());
1031             EditKeyFrameCommand *command = new EditKeyFrameCommand(this, m_dragItem->track(), m_dragItem->startPos(), item->selectedEffectIndex(), previous, next, false);
1032             m_commandStack->push(command);
1033             updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
1034             emit clipItemSelected(item, item->selectedEffectIndex());
1035         }
1036     } else if (m_dragItem && !m_dragItem->isItemLocked()) {
1037         ClipDurationDialog d(m_dragItem, m_document->timecode(), this);
1038         GenTime minimum;
1039         GenTime maximum;
1040         if (m_dragItem->type() == TRANSITIONWIDGET) {
1041             getTransitionAvailableSpace(m_dragItem, minimum, maximum);
1042         } else {
1043             getClipAvailableSpace(m_dragItem, minimum, maximum);
1044         }
1045         //kDebug()<<"// GOT MOVE POS: "<<minimum.frames(25)<<" - "<<maximum.frames(25);
1046         d.setMargins(minimum, maximum);
1047         if (d.exec() == QDialog::Accepted) {
1048             if (m_dragItem->type() == TRANSITIONWIDGET) {
1049                 // move & resize transition
1050                 ItemInfo startInfo;
1051                 startInfo.startPos = m_dragItem->startPos();
1052                 startInfo.endPos = m_dragItem->endPos();
1053                 startInfo.track = m_dragItem->track();
1054                 ItemInfo endInfo;
1055                 endInfo.startPos = d.startPos();
1056                 endInfo.endPos = endInfo.startPos + d.duration();
1057                 endInfo.track = m_dragItem->track();
1058                 MoveTransitionCommand *command = new MoveTransitionCommand(this, startInfo, endInfo, true);
1059                 m_commandStack->push(command);
1060             } else {
1061                 // move and resize clip
1062                 QUndoCommand *moveCommand = new QUndoCommand();
1063                 moveCommand->setText(i18n("Edit clip"));
1064                 ItemInfo clipInfo = m_dragItem->info();
1065                 if (d.duration() < m_dragItem->cropDuration() || d.cropStart() != clipInfo.cropStart) {
1066                     // duration was reduced, so process it first
1067                     ItemInfo startInfo = clipInfo;
1068                     clipInfo.endPos = clipInfo.startPos + d.duration();
1069                     clipInfo.cropStart = d.cropStart();
1070                     new ResizeClipCommand(this, startInfo, clipInfo, true, moveCommand);
1071                 }
1072                 if (d.startPos() != clipInfo.startPos) {
1073                     ItemInfo startInfo = clipInfo;
1074                     clipInfo.startPos = d.startPos();
1075                     clipInfo.endPos = m_dragItem->endPos() + (clipInfo.startPos - startInfo.startPos);
1076                     new MoveClipCommand(this, startInfo, clipInfo, true, moveCommand);
1077                 }
1078                 if (d.duration() > m_dragItem->cropDuration()) {
1079                     // duration was increased, so process it after move
1080                     ItemInfo startInfo = clipInfo;
1081                     clipInfo.endPos = clipInfo.startPos + d.duration();
1082                     clipInfo.cropStart = d.cropStart();
1083                     new ResizeClipCommand(this, startInfo, clipInfo, true, moveCommand);
1084                 }
1085                 m_commandStack->push(moveCommand);
1086             }
1087         }
1088     } else {
1089         QList<QGraphicsItem *> collisionList = items(event->pos());
1090         if (collisionList.count() == 1 && collisionList.at(0)->type() == GUIDEITEM) {
1091             Guide *editGuide = (Guide *) collisionList.at(0);
1092             if (editGuide) slotEditGuide(editGuide->info());
1093         }
1094     }
1095 }
1096
1097
1098 void CustomTrackView::editKeyFrame(const GenTime pos, const int track, const int index, const QString keyframes)
1099 {
1100     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()), track);
1101     if (clip) {
1102         clip->setKeyframes(index, keyframes);
1103         updateEffect(m_document->tracksCount() - clip->track(), clip->startPos(), clip->effectAt(index), index);
1104     } else emit displayMessage(i18n("Cannot find clip with keyframe"), ErrorMessage);
1105 }
1106
1107
1108 void CustomTrackView::displayContextMenu(QPoint pos, AbstractClipItem *clip, AbstractGroupItem *group)
1109 {
1110     m_deleteGuide->setEnabled(m_dragGuide != NULL);
1111     m_editGuide->setEnabled(m_dragGuide != NULL);
1112     if (clip == NULL) m_timelineContextMenu->popup(pos);
1113     else if (group != NULL) {
1114         m_changeSpeedAction->setEnabled(false);
1115         m_pasteEffectsAction->setEnabled(m_copiedItems.count() == 1);
1116         m_ungroupAction->setEnabled(true);
1117         updateClipTypeActions(NULL);
1118         m_timelineContextClipMenu->popup(pos);
1119     } else {
1120         m_ungroupAction->setEnabled(false);
1121         if (clip->type() == AVWIDGET) {
1122             ClipItem *item = static_cast <ClipItem*>(clip);
1123             updateClipTypeActions(item);
1124             m_changeSpeedAction->setEnabled(item->clipType() == AV || item->clipType() == VIDEO);
1125             m_pasteEffectsAction->setEnabled(m_copiedItems.count() == 1);
1126             m_timelineContextClipMenu->popup(pos);
1127         } else if (clip->type() == TRANSITIONWIDGET) m_timelineContextTransitionMenu->popup(pos);
1128     }
1129 }
1130
1131 void CustomTrackView::activateMonitor()
1132 {
1133     emit activateDocumentMonitor();
1134 }
1135
1136 void CustomTrackView::dragEnterEvent(QDragEnterEvent * event)
1137 {
1138     if (event->mimeData()->hasFormat("kdenlive/clip")) {
1139         m_clipDrag = true;
1140         resetSelectionGroup();
1141         QStringList list = QString(event->mimeData()->data("kdenlive/clip")).split(';');
1142         m_selectionGroup = new AbstractGroupItem(m_document->fps());
1143         QPoint pos;
1144         DocClipBase *clip = m_document->getBaseClip(list.at(0));
1145         if (clip == NULL) kDebug() << " WARNING))))))))) CLIP NOT FOUND : " << list.at(0);
1146         ItemInfo info;
1147         info.startPos = GenTime();
1148         info.cropStart = GenTime(list.at(1).toInt(), m_document->fps());
1149         info.endPos = GenTime(list.at(2).toInt() - list.at(1).toInt(), m_document->fps());
1150         info.track = (int)(1 / m_tracksHeight);
1151         ClipItem *item = new ClipItem(clip, info, m_document->fps(), 1.0);
1152         m_selectionGroup->addToGroup(item);
1153         item->setFlags(QGraphicsItem::ItemIsSelectable);
1154         //TODO: check if we do not overlap another clip when first dropping in timeline
1155         // if (insertPossible(m_selectionGroup, event->pos()))
1156         QList <GenTime> offsetList;
1157         offsetList.append(info.endPos);
1158         updateSnapPoints(NULL, offsetList);
1159         scene()->addItem(m_selectionGroup);
1160         event->acceptProposedAction();
1161     } else if (event->mimeData()->hasFormat("kdenlive/producerslist")) {
1162         m_clipDrag = true;
1163         QStringList ids = QString(event->mimeData()->data("kdenlive/producerslist")).split(';');
1164         m_scene->clearSelection();
1165         resetSelectionGroup(false);
1166
1167         m_selectionGroup = new AbstractGroupItem(m_document->fps());
1168         QPoint pos;
1169         GenTime start;
1170         QList <GenTime> offsetList;
1171         for (int i = 0; i < ids.size(); ++i) {
1172             DocClipBase *clip = m_document->getBaseClip(ids.at(i));
1173             if (clip == NULL) kDebug() << " WARNING))))))))) CLIP NOT FOUND : " << ids.at(i);
1174             ItemInfo info;
1175             info.startPos = start;
1176             info.endPos = info.startPos + clip->duration();
1177             info.track = (int)(1 / m_tracksHeight);
1178             ClipItem *item = new ClipItem(clip, info, m_document->fps(), 1.0, false);
1179             start += clip->duration();
1180             offsetList.append(start);
1181             m_selectionGroup->addToGroup(item);
1182             item->setFlags(QGraphicsItem::ItemIsSelectable);
1183             m_waitingThumbs.append(item);
1184         }
1185         //TODO: check if we do not overlap another clip when first dropping in timeline
1186         //if (insertPossible(m_selectionGroup, event->pos()))
1187         updateSnapPoints(NULL, offsetList);
1188         scene()->addItem(m_selectionGroup);
1189         m_thumbsTimer.start();
1190         event->acceptProposedAction();
1191
1192     } else {
1193         // the drag is not a clip (may be effect, ...)
1194         m_clipDrag = false;
1195         QGraphicsView::dragEnterEvent(event);
1196     }
1197 }
1198
1199
1200 bool CustomTrackView::insertPossible(AbstractGroupItem *group, const QPoint &pos) const
1201 {
1202     QPolygonF path;
1203     QList<QGraphicsItem *> children = group->childItems();
1204     for (int i = 0; i < children.count(); i++) {
1205         if (children.at(i)->type() == AVWIDGET) {
1206             ClipItem *clip = static_cast <ClipItem *>(children.at(i));
1207             ItemInfo info = clip->info();
1208             kDebug() << " / / INSERT : " << pos.x();
1209             QRectF shape = QRectF(clip->startPos().frames(m_document->fps()), clip->track() * m_tracksHeight + 1, clip->cropDuration().frames(m_document->fps()) - 0.02, m_tracksHeight - 1);
1210             kDebug() << " / / INSERT RECT: " << shape;
1211             path = path.united(QPolygonF(shape));
1212         }
1213     }
1214
1215     QList<QGraphicsItem*> collindingItems = scene()->items(path, Qt::IntersectsItemShape);
1216     if (collindingItems.isEmpty()) return true;
1217     else {
1218         for (int i = 0; i < collindingItems.count(); i++) {
1219             QGraphicsItem *collision = collindingItems.at(i);
1220             if (collision->type() == AVWIDGET) {
1221                 // Collision
1222                 kDebug() << "// COLLISIION DETECTED";
1223                 return false;
1224             }
1225         }
1226         return true;
1227     }
1228
1229 }
1230
1231 void CustomTrackView::slotRefreshEffects(ClipItem *clip)
1232 {
1233     int track = m_document->tracksCount() - clip->track();
1234     GenTime pos = clip->startPos();
1235     if (!m_document->renderer()->mltRemoveEffect(track, pos, "-1", false, false)) {
1236         emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
1237         return;
1238     }
1239     bool success = true;
1240     for (int i = 0; i < clip->effectsCount(); i++) {
1241         if (!m_document->renderer()->mltAddEffect(track, pos, clip->getEffectArgs(clip->effectAt(i)), false)) success = false;
1242     }
1243     if (!success) emit displayMessage(i18n("Problem adding effect to clip"), ErrorMessage);
1244     m_document->renderer()->doRefresh();
1245 }
1246
1247 void CustomTrackView::addEffect(int track, GenTime pos, QDomElement effect)
1248 {
1249     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1250     if (clip) {
1251         if (!m_document->renderer()->mltAddEffect(track, pos, clip->addEffect(effect)))
1252             emit displayMessage(i18n("Problem adding effect to clip"), ErrorMessage);
1253         emit clipItemSelected(clip);
1254     } else emit displayMessage(i18n("Cannot find clip to add effect"), ErrorMessage);
1255 }
1256
1257 void CustomTrackView::deleteEffect(int track, GenTime pos, QDomElement effect)
1258 {
1259     QString index = effect.attribute("kdenlive_ix");
1260     if (!m_document->renderer()->mltRemoveEffect(track, pos, index, true) && effect.attribute("disabled") != "1") {
1261         kDebug() << "// ERROR REMOV EFFECT: " << index << ", DISABLE: " << effect.attribute("disabled");
1262         emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
1263         return;
1264     }
1265     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1266     if (clip) {
1267         clip->deleteEffect(index);
1268         emit clipItemSelected(clip);
1269     }
1270 }
1271
1272 void CustomTrackView::slotAddGroupEffect(QDomElement effect, AbstractGroupItem *group)
1273 {
1274     QList<QGraphicsItem *> itemList = group->childItems();
1275     QUndoCommand *effectCommand = new QUndoCommand();
1276     QString effectName;
1277     QDomNode namenode = effect.elementsByTagName("name").item(0);
1278     if (!namenode.isNull()) effectName = i18n(namenode.toElement().text().toUtf8().data());
1279     else effectName = i18n("effect");
1280     effectCommand->setText(i18n("Add %1", effectName));
1281     int count = 0;
1282     for (int i = 0; i < itemList.count(); i++) {
1283         if (itemList.at(i)->type() == AVWIDGET) {
1284             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
1285             if (effect.attribute("type") == "audio") {
1286                 // Don't add audio effects on video clips
1287                 if (item->isVideoOnly() || (item->clipType() != AUDIO && item->clipType() != AV && item->clipType() != PLAYLIST)) continue;
1288             } else if (effect.hasAttribute("type") == false) {
1289                 // Don't add video effect on audio clips
1290                 if (item->isAudioOnly() || item->clipType() == AUDIO) continue;
1291             }
1292
1293             if (item->hasEffect(effect.attribute("tag"), effect.attribute("id")) != -1 && effect.attribute("unique", "0") != "0") {
1294                 emit displayMessage(i18n("Effect already present in clip"), ErrorMessage);
1295                 continue;
1296             }
1297             if (item->isItemLocked()) {
1298                 continue;
1299             }
1300             item->initEffect(effect);
1301             if (effect.attribute("tag") == "ladspa") {
1302                 QString ladpsaFile = m_document->getLadspaFile();
1303                 initEffects::ladspaEffectFile(ladpsaFile, effect.attribute("ladspaid").toInt(), getLadspaParams(effect));
1304                 effect.setAttribute("src", ladpsaFile);
1305             }
1306             new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), effect, true, effectCommand);
1307             count++;
1308         }
1309     }
1310     if (count > 0) {
1311         m_commandStack->push(effectCommand);
1312         setDocumentModified();
1313     } else delete effectCommand;
1314 }
1315
1316 void CustomTrackView::slotAddEffect(QDomElement effect, GenTime pos, int track)
1317 {
1318     QList<QGraphicsItem *> itemList;
1319     QUndoCommand *effectCommand = new QUndoCommand();
1320     QString effectName;
1321     QDomNode namenode = effect.elementsByTagName("name").item(0);
1322     if (!namenode.isNull()) effectName = i18n(namenode.toElement().text().toUtf8().data());
1323     else effectName = i18n("effect");
1324     effectCommand->setText(i18n("Add %1", effectName));
1325     int count = 0;
1326     if (track == -1) itemList = scene()->selectedItems();
1327     if (itemList.isEmpty()) {
1328         ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, track);
1329         if (clip) itemList.append(clip);
1330         else emit displayMessage(i18n("Select a clip if you want to apply an effect"), ErrorMessage);
1331     }
1332     kDebug() << "// REQUESTING EFFECT ON CLIP: " << pos.frames(25) << ", TRK: " << track << "SELECTED ITEMS: " << itemList.count();
1333     for (int i = 0; i < itemList.count(); i++) {
1334         if (itemList.at(i)->type() == AVWIDGET) {
1335             ClipItem *item = (ClipItem *)itemList.at(i);
1336             if (effect.attribute("type") == "audio") {
1337                 // Don't add audio effects on video clips
1338                 if (item->isVideoOnly() || (item->clipType() != AUDIO && item->clipType() != AV && item->clipType() != PLAYLIST)) {
1339                     emit displayMessage(i18n("Cannot add an audio effect to this clip"), ErrorMessage);
1340                     continue;
1341                 }
1342             } else if (effect.hasAttribute("type") == false) {
1343                 // Don't add video effect on audio clips
1344                 if (item->isAudioOnly() || item->clipType() == AUDIO) {
1345                     emit displayMessage(i18n("Cannot add a video effect to this clip"), ErrorMessage);
1346                     continue;
1347                 }
1348             }
1349             if (item->hasEffect(effect.attribute("tag"), effect.attribute("id")) != -1 && effect.attribute("unique", "0") != "0") {
1350                 emit displayMessage(i18n("Effect already present in clip"), ErrorMessage);
1351                 continue;
1352             }
1353             if (item->isItemLocked()) {
1354                 continue;
1355             }
1356             item->initEffect(effect);
1357             if (effect.attribute("tag") == "ladspa") {
1358                 QString ladpsaFile = m_document->getLadspaFile();
1359                 initEffects::ladspaEffectFile(ladpsaFile, effect.attribute("ladspaid").toInt(), getLadspaParams(effect));
1360                 effect.setAttribute("src", ladpsaFile);
1361             }
1362             new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), effect, true, effectCommand);
1363             count++;
1364         }
1365     }
1366     if (count > 0) {
1367         m_commandStack->push(effectCommand);
1368         setDocumentModified();
1369     } else delete effectCommand;
1370 }
1371
1372 void CustomTrackView::slotDeleteEffect(ClipItem *clip, QDomElement effect)
1373 {
1374     AddEffectCommand *command = new AddEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), effect, false);
1375     m_commandStack->push(command);
1376     setDocumentModified();
1377 }
1378
1379 void CustomTrackView::updateEffect(int track, GenTime pos, QDomElement effect, int ix, bool triggeredByUser)
1380 {
1381     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1382     if (clip) {
1383         EffectsParameterList effectParams = clip->getEffectArgs(effect);
1384         if (effect.attribute("tag") == "ladspa") {
1385             // Update the ladspa affect file
1386             initEffects::ladspaEffectFile(effect.attribute("src"), effect.attribute("ladspaid").toInt(), getLadspaParams(effect));
1387         }
1388         // check if we are trying to reset a keyframe effect
1389         if (effectParams.hasParam("keyframes") && effectParams.paramValue("keyframes").isEmpty()) {
1390             clip->initEffect(effect);
1391             clip->setEffectAt(ix, effect);
1392             effectParams = clip->getEffectArgs(effect);
1393         }
1394         if (effectParams.paramValue("disabled") == "1") {
1395             if (m_document->renderer()->mltRemoveEffect(track, pos, effectParams.paramValue("kdenlive_ix"), false)) {
1396                 kDebug() << "//////  DISABLING EFFECT: " << ix << ", CURRENTLA: " << clip->selectedEffectIndex();
1397             } else emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
1398         } else if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - clip->track(), clip->startPos(), effectParams))
1399             emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
1400
1401         clip->setEffectAt(ix, effect);
1402         if (ix == clip->selectedEffectIndex()) {
1403             clip->setSelectedEffect(ix);
1404             if (!triggeredByUser) emit clipItemSelected(clip, ix);
1405         }
1406         if (effect.attribute("tag") == "volume" || effect.attribute("tag") == "brightness") {
1407             // A fade effect was modified, update the clip
1408             if (effect.attribute("id") == "fadein" || effect.attribute("id") == "fade_from_black") {
1409                 int pos = effectParams.paramValue("out").toInt() - effectParams.paramValue("in").toInt();
1410                 clip->setFadeIn(pos);
1411             }
1412             if (effect.attribute("id") == "fadeout" || effect.attribute("id") == "fade_to_black") {
1413                 int pos = effectParams.paramValue("out").toInt() - effectParams.paramValue("in").toInt();
1414                 clip->setFadeOut(pos);
1415             }
1416         }
1417     }
1418     setDocumentModified();
1419 }
1420
1421 void CustomTrackView::moveEffect(int track, GenTime pos, int oldPos, int newPos)
1422 {
1423     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1424     if (clip) {
1425         m_document->renderer()->mltMoveEffect(track, pos, oldPos, newPos);
1426         QDomElement act = clip->effectAt(newPos - 1).cloneNode().toElement();
1427         QDomElement before = clip->effectAt(oldPos - 1).cloneNode().toElement();
1428         clip->setEffectAt(oldPos - 1, act);
1429         clip->setEffectAt(newPos - 1, before);
1430         emit clipItemSelected(clip, newPos - 1);
1431     }
1432     setDocumentModified();
1433 }
1434
1435 void CustomTrackView::slotChangeEffectState(ClipItem *clip, int effectPos, bool disable)
1436 {
1437     QDomElement effect = clip->effectAt(effectPos);
1438     QDomElement oldEffect = effect.cloneNode().toElement();
1439     effect.setAttribute("disabled", disable);
1440     EditEffectCommand *command = new EditEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), oldEffect, effect, effectPos, true);
1441     m_commandStack->push(command);
1442     setDocumentModified();;
1443 }
1444
1445 void CustomTrackView::slotChangeEffectPosition(ClipItem *clip, int currentPos, int newPos)
1446 {
1447     MoveEffectCommand *command = new MoveEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), currentPos, newPos);
1448     m_commandStack->push(command);
1449     setDocumentModified();
1450 }
1451
1452 void CustomTrackView::slotUpdateClipEffect(ClipItem *clip, QDomElement oldeffect, QDomElement effect, int ix)
1453 {
1454     EditEffectCommand *command = new EditEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), oldeffect, effect, ix, true);
1455     m_commandStack->push(command);
1456 }
1457
1458 void CustomTrackView::cutClip(ItemInfo info, GenTime cutTime, bool cut)
1459 {
1460     if (cut) {
1461         // cut clip
1462         ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
1463         if (!item || cutTime >= item->endPos() || cutTime <= item->startPos()) {
1464             emit displayMessage(i18n("Cannot find clip to cut"), ErrorMessage);
1465             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);
1466             m_blockRefresh = false;
1467             return;
1468         }
1469         if (item->parentItem()) {
1470             // Item is part of a group, reset group
1471             resetSelectionGroup();
1472         }
1473         kDebug() << "/////////  CUTTING CLIP : (" << item->startPos().frames(25) << "-" << item->endPos().frames(25) << "), INFO: (" << info.startPos.frames(25) << "-" << info.endPos.frames(25) << ")" << ", CUT: " << cutTime.frames(25);
1474
1475         m_document->renderer()->mltCutClip(m_document->tracksCount() - info.track, cutTime);
1476         int cutPos = (int) cutTime.frames(m_document->fps());
1477         ItemInfo newPos;
1478         double speed = item->speed();
1479         newPos.startPos = cutTime;
1480         newPos.endPos = info.endPos;
1481         if (speed == 1) newPos.cropStart = item->info().cropStart + (cutTime - info.startPos);
1482         else newPos.cropStart = item->info().cropStart + (cutTime - info.startPos) * speed;
1483         newPos.track = info.track;
1484         ClipItem *dup = item->clone(newPos);
1485         // remove unwanted effects (fade in) from 2nd part of cutted clip
1486         int ix = dup->hasEffect(QString(), "fadein");
1487         if (ix != -1) {
1488             QDomElement oldeffect = item->effectAt(ix);
1489             dup->deleteEffect(oldeffect.attribute("kdenlive_ix"));
1490         }
1491         ix = dup->hasEffect(QString(), "fade_from_black");
1492         if (ix != -1) {
1493             QDomElement oldeffect = item->effectAt(ix);
1494             dup->deleteEffect(oldeffect.attribute("kdenlive_ix"));
1495         }
1496         item->resizeEnd(cutPos, false);
1497         scene()->addItem(dup);
1498         if (item->checkKeyFrames()) slotRefreshEffects(item);
1499         if (dup->checkKeyFrames()) slotRefreshEffects(dup);
1500         item->baseClip()->addReference();
1501         m_document->updateClip(item->baseClip()->getId());
1502         setDocumentModified();
1503         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);
1504         kDebug() << "//  CUTTING CLIP dONE";
1505     } else {
1506         // uncut clip
1507
1508         ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
1509         ClipItem *dup = getClipItemAt((int) cutTime.frames(m_document->fps()) + 1, info.track);
1510         if (!item || !dup || item == dup) {
1511             emit displayMessage(i18n("Cannot find clip to uncut"), ErrorMessage);
1512             m_blockRefresh = false;
1513             return;
1514         }
1515         if (m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, cutTime) == false) {
1516             emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(cutTime.frames(m_document->fps())), info.track), ErrorMessage);
1517             return;
1518         }
1519
1520         kDebug() << "// UNCUTTING CLIPS: ITEM 1 (" << item->startPos().frames(25) << "x" << item->endPos().frames(25) << ")";
1521         kDebug() << "// UNCUTTING CLIPS: ITEM 2 (" << dup->startPos().frames(25) << "x" << dup->endPos().frames(25) << ")";
1522         kDebug() << "// UNCUTTING CLIPS, INFO (" << info.startPos.frames(25) << "x" << info.endPos.frames(25) << ") , CUT: " << cutTime.frames(25);;
1523         //deleteClip(dup->info());
1524
1525
1526         if (dup->isSelected()) emit clipItemSelected(NULL);
1527         dup->baseClip()->removeReference();
1528         m_document->updateClip(dup->baseClip()->getId());
1529         scene()->removeItem(dup);
1530         delete dup;
1531
1532         ItemInfo clipinfo = item->info();
1533         clipinfo.track = m_document->tracksCount() - clipinfo.track;
1534         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, info.endPos - info.startPos);
1535         if (success) {
1536             item->resizeEnd((int) info.endPos.frames(m_document->fps()));
1537             setDocumentModified();
1538         } else
1539             emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
1540
1541     }
1542     QTimer::singleShot(3000, this, SLOT(slotEnableRefresh()));
1543 }
1544
1545 void CustomTrackView::slotEnableRefresh()
1546 {
1547     m_blockRefresh = false;
1548 }
1549
1550 void CustomTrackView::slotAddTransitionToSelectedClips(QDomElement transition)
1551 {
1552     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1553     if (itemList.count() == 1) {
1554         if (itemList.at(0)->type() == AVWIDGET) {
1555             ClipItem *item = (ClipItem *) itemList.at(0);
1556             ItemInfo info;
1557             info.track = item->track();
1558             ClipItem *transitionClip = NULL;
1559             const int transitiontrack = getPreviousVideoTrack(info.track);
1560             GenTime pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
1561             if (pos < item->startPos() + item->cropDuration() / 2) {
1562                 // add transition to clip start
1563                 info.startPos = item->startPos();
1564                 if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.startPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
1565                 if (transitionClip && transitionClip->endPos() < item->endPos()) {
1566                     info.endPos = transitionClip->endPos();
1567                 } else info.endPos = info.startPos + GenTime(65, m_document->fps());
1568                 // Check there is no other transition at that place
1569                 double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
1570                 QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
1571                 QList<QGraphicsItem *> selection = m_scene->items(r);
1572                 bool transitionAccepted = true;
1573                 for (int i = 0; i < selection.count(); i++) {
1574                     if (selection.at(i)->type() == TRANSITIONWIDGET) {
1575                         Transition *tr = static_cast <Transition *>(selection.at(i));
1576                         if (tr->startPos() - info.startPos > GenTime(5, m_document->fps())) {
1577                             if (tr->startPos() < info.endPos) info.endPos = tr->startPos();
1578                         } else transitionAccepted = false;
1579                     }
1580                 }
1581                 if (transitionAccepted) slotAddTransition(item, info, transitiontrack, transition);
1582                 else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1583
1584             } else {
1585                 // add transition to clip  end
1586                 info.endPos = item->endPos();
1587                 if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.endPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
1588                 if (transitionClip && transitionClip->startPos() > item->startPos()) {
1589                     info.startPos = transitionClip->startPos();
1590                 } else info.startPos = info.endPos - GenTime(65, m_document->fps());
1591                 if (transition.attribute("tag") == "luma") EffectsList::setParameter(transition, "reverse", "1");
1592                 else if (transition.attribute("id") == "slide") EffectsList::setParameter(transition, "invert", "1");
1593
1594                 // Check there is no other transition at that place
1595                 double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
1596                 QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
1597                 QList<QGraphicsItem *> selection = m_scene->items(r);
1598                 bool transitionAccepted = true;
1599                 for (int i = 0; i < selection.count(); i++) {
1600                     if (selection.at(i)->type() == TRANSITIONWIDGET) {
1601                         Transition *tr = static_cast <Transition *>(selection.at(i));
1602                         if (info.endPos - tr->endPos() > GenTime(5, m_document->fps())) {
1603                             if (tr->endPos() > info.startPos) info.startPos = tr->endPos();
1604                         } else transitionAccepted = false;
1605                     }
1606                 }
1607                 if (transitionAccepted) slotAddTransition(item, info, transitiontrack, transition);
1608                 else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1609             }
1610         }
1611     } else for (int i = 0; i < itemList.count(); i++) {
1612             if (itemList.at(i)->type() == AVWIDGET) {
1613                 ClipItem *item = (ClipItem *) itemList.at(i);
1614                 ItemInfo info;
1615                 info.startPos = item->startPos();
1616                 info.endPos = info.startPos + GenTime(65, m_document->fps());
1617                 info.track = item->track();
1618
1619                 // Check there is no other transition at that place
1620                 double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
1621                 QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
1622                 QList<QGraphicsItem *> selection = m_scene->items(r);
1623                 bool transitionAccepted = true;
1624                 for (int i = 0; i < selection.count(); i++) {
1625                     if (selection.at(i)->type() == TRANSITIONWIDGET) {
1626                         Transition *tr = static_cast <Transition *>(selection.at(i));
1627                         if (tr->startPos() - info.startPos > GenTime(5, m_document->fps())) {
1628                             if (tr->startPos() < info.endPos) info.endPos = tr->startPos();
1629                         } else transitionAccepted = false;
1630                     }
1631                 }
1632                 int transitiontrack = getPreviousVideoTrack(info.track);
1633                 if (transitionAccepted) slotAddTransition(item, info, transitiontrack, transition);
1634                 else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1635             }
1636         }
1637 }
1638
1639 void CustomTrackView::slotAddTransition(ClipItem* /*clip*/, ItemInfo transitionInfo, int endTrack, QDomElement transition)
1640 {
1641     if (transitionInfo.startPos >= transitionInfo.endPos) {
1642         emit displayMessage(i18n("Invalid transition"), ErrorMessage);
1643         return;
1644     }
1645     AddTransitionCommand* command = new AddTransitionCommand(this, transitionInfo, endTrack, transition, false, true);
1646     m_commandStack->push(command);
1647     setDocumentModified();
1648 }
1649
1650 void CustomTrackView::addTransition(ItemInfo transitionInfo, int endTrack, QDomElement params)
1651 {
1652     Transition *tr = new Transition(transitionInfo, endTrack, m_document->fps(), params, true);
1653     //kDebug() << "---- ADDING transition " << params.attribute("value");
1654     if (m_document->renderer()->mltAddTransition(tr->transitionTag(), endTrack, m_document->tracksCount() - transitionInfo.track, transitionInfo.startPos, transitionInfo.endPos, tr->toXML())) {
1655         scene()->addItem(tr);
1656         setDocumentModified();
1657     } else {
1658         emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1659         delete tr;
1660     }
1661 }
1662
1663 void CustomTrackView::deleteTransition(ItemInfo transitionInfo, int endTrack, QDomElement /*params*/)
1664 {
1665     Transition *item = getTransitionItemAt(transitionInfo.startPos, transitionInfo.track);
1666     if (!item) {
1667         emit displayMessage(i18n("Select clip to delete"), ErrorMessage);
1668         return;
1669     }
1670     m_document->renderer()->mltDeleteTransition(item->transitionTag(), endTrack, m_document->tracksCount() - transitionInfo.track, transitionInfo.startPos, transitionInfo.endPos, item->toXML());
1671     if (m_dragItem == item) m_dragItem = NULL;
1672     delete item;
1673     emit transitionItemSelected(NULL);
1674     setDocumentModified();
1675 }
1676
1677 void CustomTrackView::slotTransitionUpdated(Transition *tr, QDomElement old)
1678 {
1679     kDebug() << "TRANS UPDATE, TRACKS: " << old.attribute("transition_btrack") << ", NEW: " << tr->toXML().attribute("transition_btrack");
1680     EditTransitionCommand *command = new EditTransitionCommand(this, tr->track(), tr->startPos(), old, tr->toXML(), false);
1681     m_commandStack->push(command);
1682     setDocumentModified();
1683 }
1684
1685 void CustomTrackView::updateTransition(int track, GenTime pos, QDomElement oldTransition, QDomElement transition, bool updateTransitionWidget)
1686 {
1687     Transition *item = getTransitionItemAt(pos, track);
1688     if (!item) {
1689         kWarning() << "Unable to find transition at pos :" << pos.frames(m_document->fps()) << ", ON track: " << track;
1690         return;
1691     }
1692     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);
1693     //kDebug() << "ORIGINAL TRACK: "<< oldTransition.attribute("transition_btrack") << ", NEW TRACK: "<<transition.attribute("transition_btrack");
1694     item->setTransitionParameters(transition);
1695     if (updateTransitionWidget) {
1696         ItemInfo info = item->info();
1697         QPoint p;
1698         ClipItem *transitionClip = getClipItemAt(info.startPos, info.track);
1699         if (transitionClip && transitionClip->baseClip()) {
1700             QString size = transitionClip->baseClip()->getProperty("frame_size");
1701             p.setX(size.section('x', 0, 0).toInt());
1702             p.setY(size.section('x', 1, 1).toInt());
1703         }
1704         emit transitionItemSelected(item, getPreviousVideoTrack(info.track), p, true);
1705     }
1706     setDocumentModified();
1707 }
1708
1709 void CustomTrackView::dragMoveEvent(QDragMoveEvent * event)
1710 {
1711     event->setDropAction(Qt::IgnoreAction);
1712     const QPointF pos = mapToScene(event->pos());
1713     if (m_selectionGroup && m_clipDrag) {
1714         m_selectionGroup->setPos(pos.x(), pos.y());
1715         emit mousePosition((int)(m_selectionGroup->scenePos().x() + 0.5));
1716         event->setDropAction(Qt::MoveAction);
1717         event->acceptProposedAction();
1718     } else {
1719         QGraphicsView::dragMoveEvent(event);
1720     }
1721 }
1722
1723 void CustomTrackView::dragLeaveEvent(QDragLeaveEvent * event)
1724 {
1725     if (m_selectionGroup && m_clipDrag) {
1726         m_thumbsTimer.stop();
1727         m_waitingThumbs.clear();
1728         QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1729         qDeleteAll(items);
1730         scene()->destroyItemGroup(m_selectionGroup);
1731         m_selectionGroup = NULL;
1732     } else QGraphicsView::dragLeaveEvent(event);
1733 }
1734
1735 void CustomTrackView::dropEvent(QDropEvent * event)
1736 {
1737     if (m_selectionGroup && m_clipDrag) {
1738         QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1739         resetSelectionGroup();
1740         m_scene->clearSelection();
1741         bool hasVideoClip = false;
1742         QUndoCommand *addCommand = new QUndoCommand();
1743         addCommand->setText(i18n("Add timeline clip"));
1744
1745         for (int i = 0; i < items.count(); i++) {
1746             ClipItem *item = static_cast <ClipItem *>(items.at(i));
1747             if (!hasVideoClip && (item->clipType() == AV || item->clipType() == VIDEO)) hasVideoClip = true;
1748             if (items.count() == 1) {
1749                 updateClipTypeActions(item);
1750             } else {
1751                 updateClipTypeActions(NULL);
1752             }
1753
1754             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, false, addCommand);
1755             item->baseClip()->addReference();
1756             m_document->updateClip(item->baseClip()->getId());
1757             ItemInfo info = item->info();
1758
1759             int tracknumber = m_document->tracksCount() - info.track - 1;
1760             bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
1761             if (isLocked) item->setItemLocked(true);
1762
1763             if (item->baseClip()->isTransparent() && getTransitionItemAtStart(info.startPos, info.track) == NULL) {
1764                 // add transparency transition
1765                 new AddTransitionCommand(this, info, getPreviousVideoTrack(info.track), MainWindow::transitions.getEffectByTag("composite", "composite"), false, true, addCommand);
1766             }
1767             info.track = m_document->tracksCount() - item->track();
1768             m_document->renderer()->mltInsertClip(info, item->xml(), item->baseClip()->producer(item->track()));
1769             item->setSelected(true);
1770         }
1771         m_commandStack->push(addCommand);
1772         setDocumentModified();
1773         m_changeSpeedAction->setEnabled(hasVideoClip);
1774         m_pasteEffectsAction->setEnabled(m_copiedItems.count() == 1);
1775         if (items.count() > 1) groupSelectedItems(true);
1776     } else QGraphicsView::dropEvent(event);
1777     setFocus();
1778 }
1779
1780
1781 QStringList CustomTrackView::mimeTypes() const
1782 {
1783     QStringList qstrList;
1784     // list of accepted mime types for drop
1785     qstrList.append("text/plain");
1786     qstrList.append("kdenlive/producerslist");
1787     qstrList.append("kdenlive/clip");
1788     return qstrList;
1789 }
1790
1791 Qt::DropActions CustomTrackView::supportedDropActions() const
1792 {
1793     // returns what actions are supported when dropping
1794     return Qt::MoveAction;
1795 }
1796
1797 void CustomTrackView::setDuration(int duration)
1798 {
1799     int diff = qAbs(duration - sceneRect().width());
1800     if (diff * matrix().m11() > -50) {
1801         if (matrix().m11() < 0.4) setSceneRect(0, 0, (duration + 100 / matrix().m11()), sceneRect().height());
1802         else setSceneRect(0, 0, (duration + 300), sceneRect().height());
1803     }
1804     m_projectDuration = duration;
1805 }
1806
1807 int CustomTrackView::duration() const
1808 {
1809     return m_projectDuration;
1810 }
1811
1812 void CustomTrackView::addTrack(TrackInfo type, int ix)
1813 {
1814     if (ix == -1 || ix == m_document->tracksCount()) {
1815         m_document->insertTrack(ix, type);
1816         m_document->renderer()->mltInsertTrack(1, type.type == VIDEOTRACK);
1817     } else {
1818         m_document->insertTrack(m_document->tracksCount() - ix, type);
1819         // insert track in MLT playlist
1820         m_document->renderer()->mltInsertTrack(m_document->tracksCount() - ix, type.type == VIDEOTRACK);
1821
1822         double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
1823         QRectF r(0, startY, sceneRect().width(), sceneRect().height() - startY);
1824         QList<QGraphicsItem *> selection = m_scene->items(r);
1825         resetSelectionGroup();
1826
1827         m_selectionGroup = new AbstractGroupItem(m_document->fps());
1828         scene()->addItem(m_selectionGroup);
1829         for (int i = 0; i < selection.count(); i++) {
1830             if ((!selection.at(i)->parentItem()) && (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET || selection.at(i)->type() == GROUPWIDGET)) {
1831                 m_selectionGroup->addToGroup(selection.at(i));
1832                 selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
1833             }
1834         }
1835         // Move graphic items
1836         m_selectionGroup->translate(0, m_tracksHeight);
1837
1838         // adjust track number
1839         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
1840         for (int i = 0; i < children.count(); i++) {
1841             if (children.at(i)->type() == GROUPWIDGET) {
1842                 AbstractGroupItem *grp = static_cast<AbstractGroupItem*>(children.at(i));
1843                 children << grp->childItems();
1844                 continue;
1845             }
1846             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
1847             item->updateItem();
1848             ItemInfo clipinfo = item->info();
1849             if (item->type() == AVWIDGET) {
1850                 ClipItem *clip = static_cast <ClipItem *>(item);
1851                 // We add a move clip command so that we get the correct producer for new track number
1852                 if (clip->clipType() == AV || clip->clipType() == AUDIO) {
1853                     Mlt::Producer *prod;
1854                     if (clip->isAudioOnly()) prod = clip->baseClip()->audioProducer(clipinfo.track);
1855                     else if (clip->isVideoOnly()) prod = clip->baseClip()->videoProducer();
1856                     else prod = clip->baseClip()->producer(clipinfo.track);
1857                     m_document->renderer()->mltUpdateClipProducer((int)(m_document->tracksCount() - clipinfo.track), clipinfo.startPos.frames(m_document->fps()), prod);
1858                     kDebug() << "// UPDATING CLIP TO TRACK PROD: " << clipinfo.track;
1859                 }
1860             } else if (item->type() == TRANSITIONWIDGET) {
1861                 Transition *tr = static_cast <Transition *>(item);
1862                 int track = tr->transitionEndTrack();
1863                 if (track >= ix) {
1864                     tr->updateTransitionEndTrack(getPreviousVideoTrack(clipinfo.track));
1865                 }
1866             }
1867         }
1868         resetSelectionGroup(false);
1869     }
1870
1871     int maxHeight = m_tracksHeight * m_document->tracksCount();
1872     for (int i = 0; i < m_guides.count(); i++) {
1873         QLineF l = m_guides.at(i)->line();
1874         l.setP2(QPointF(l.x2(), maxHeight));
1875         m_guides.at(i)->setLine(l);
1876     }
1877     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), maxHeight);
1878     setSceneRect(0, 0, sceneRect().width(), maxHeight);
1879     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
1880     viewport()->update();
1881     //setFixedHeight(50 * m_tracksCount);
1882 }
1883
1884 void CustomTrackView::removeTrack(int ix)
1885 {
1886     // Delete track in MLT playlist
1887     m_document->renderer()->mltDeleteTrack(m_document->tracksCount() - ix);
1888     m_document->deleteTrack(m_document->tracksCount() - ix - 1);
1889
1890     double startY = ix * (m_tracksHeight + 1) + m_tracksHeight / 2;
1891     QRectF r(0, startY, sceneRect().width(), sceneRect().height() - startY);
1892     QList<QGraphicsItem *> selection = m_scene->items(r);
1893
1894     resetSelectionGroup();
1895
1896     m_selectionGroup = new AbstractGroupItem(m_document->fps());
1897     scene()->addItem(m_selectionGroup);
1898     for (int i = 0; i < selection.count(); i++) {
1899         if ((!selection.at(i)->parentItem()) && (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET || selection.at(i)->type() == GROUPWIDGET)) {
1900             m_selectionGroup->addToGroup(selection.at(i));
1901             selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
1902         }
1903     }
1904     // Move graphic items
1905     qreal ydiff = 0 - (int) m_tracksHeight;
1906     m_selectionGroup->translate(0, ydiff);
1907
1908     // adjust track number
1909     QList<QGraphicsItem *> children = m_selectionGroup->childItems();
1910     //kDebug() << "// FOUND CLIPS TO MOVE: " << children.count();
1911     for (int i = 0; i < children.count(); i++) {
1912         if (children.at(i)->type() == GROUPWIDGET) {
1913             AbstractGroupItem *grp = static_cast<AbstractGroupItem*>(children.at(i));
1914             children << grp->childItems();
1915             continue;
1916         }
1917         if (children.at(i)->type() == AVWIDGET) {
1918             ClipItem *clip = static_cast <ClipItem *>(children.at(i));
1919             clip->updateItem();
1920             ItemInfo clipinfo = clip->info();
1921             // We add a move clip command so that we get the correct producer for new track number
1922             if (clip->clipType() == AV || clip->clipType() == AUDIO) {
1923                 Mlt::Producer *prod;
1924                 if (clip->isAudioOnly()) prod = clip->baseClip()->audioProducer(clipinfo.track);
1925                 else if (clip->isVideoOnly()) prod = clip->baseClip()->videoProducer();
1926                 else prod = clip->baseClip()->producer(clipinfo.track);
1927                 m_document->renderer()->mltUpdateClipProducer((int)(m_document->tracksCount() - clipinfo.track), clipinfo.startPos.frames(m_document->fps()), prod);
1928             }
1929         } else if (children.at(i)->type() == TRANSITIONWIDGET) {
1930             Transition *tr = static_cast <Transition *>(children.at(i));
1931             tr->updateItem();
1932             int track = tr->transitionEndTrack();
1933             if (track >= ix) {
1934                 ItemInfo clipinfo = tr->info();
1935                 tr->updateTransitionEndTrack(getPreviousVideoTrack(clipinfo.track));
1936             }
1937         }
1938     }
1939     resetSelectionGroup(false);
1940
1941     int maxHeight = m_tracksHeight * m_document->tracksCount();
1942     for (int i = 0; i < m_guides.count(); i++) {
1943         QLineF l = m_guides.at(i)->line();
1944         l.setP2(QPointF(l.x2(), maxHeight));
1945         m_guides.at(i)->setLine(l);
1946     }
1947     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), maxHeight);
1948     setSceneRect(0, 0, sceneRect().width(), maxHeight);
1949     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
1950     viewport()->update();
1951 }
1952
1953 void CustomTrackView::changeTrack(int ix, TrackInfo type)
1954 {
1955     int tracknumber = m_document->tracksCount() - ix;
1956     m_document->setTrackType(tracknumber - 1, type);
1957     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
1958     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
1959     viewport()->update();
1960 }
1961
1962
1963 void CustomTrackView::slotSwitchTrackAudio(int ix)
1964 {
1965     /*for (int i = 0; i < m_document->tracksCount(); i++)
1966         kDebug() << "TRK " << i << " STATE: " << m_document->trackInfoAt(i).isMute << m_document->trackInfoAt(i).isBlind;*/
1967     int tracknumber = m_document->tracksCount() - ix - 1;
1968     m_document->switchTrackAudio(tracknumber, !m_document->trackInfoAt(tracknumber).isMute);
1969     kDebug() << "NEXT TRK STATE: " << m_document->trackInfoAt(tracknumber).isMute << m_document->trackInfoAt(tracknumber).isBlind;
1970     m_document->renderer()->mltChangeTrackState(tracknumber + 1, m_document->trackInfoAt(tracknumber).isMute, m_document->trackInfoAt(tracknumber).isBlind);
1971     setDocumentModified();
1972 }
1973
1974 void CustomTrackView::slotSwitchTrackLock(int ix)
1975 {
1976     int tracknumber = m_document->tracksCount() - ix - 1;
1977     LockTrackCommand *command = new LockTrackCommand(this, ix, !m_document->trackInfoAt(tracknumber).isLocked);
1978     m_commandStack->push(command);
1979 }
1980
1981
1982 void CustomTrackView::lockTrack(int ix, bool lock)
1983 {
1984     int tracknumber = m_document->tracksCount() - ix - 1;
1985     m_document->switchTrackLock(tracknumber, lock);
1986     emit doTrackLock(ix, lock);
1987     QList<QGraphicsItem *> selection = m_scene->items(0, ix * m_tracksHeight + m_tracksHeight / 2, sceneRect().width(), m_tracksHeight / 2 - 2);
1988
1989     for (int i = 0; i < selection.count(); i++) {
1990         if (selection.at(i)->type() != AVWIDGET && selection.at(i)->type() != TRANSITIONWIDGET) continue;
1991         if (selection.at(i)->isSelected()) {
1992             if (selection.at(i)->type() == AVWIDGET) emit clipItemSelected(NULL);
1993             else emit transitionItemSelected(NULL);
1994         }
1995         static_cast <AbstractClipItem *>(selection.at(i))->setItemLocked(lock);
1996     }
1997     kDebug() << "NEXT TRK STATE: " << m_document->trackInfoAt(tracknumber).isLocked;
1998     viewport()->update();
1999     setDocumentModified();
2000 }
2001
2002 void CustomTrackView::slotSwitchTrackVideo(int ix)
2003 {
2004     int tracknumber = m_document->tracksCount() - ix;
2005     m_document->switchTrackVideo(tracknumber - 1, !m_document->trackInfoAt(tracknumber - 1).isBlind);
2006     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
2007     setDocumentModified();
2008 }
2009
2010 void CustomTrackView::slotRemoveSpace()
2011 {
2012     GenTime pos;
2013     int track = 0;
2014     if (m_menuPosition.isNull()) {
2015         pos = GenTime(cursorPos(), m_document->fps());
2016         bool ok;
2017         track = QInputDialog::getInteger(this, i18n("Remove Space"), i18n("Track"), 0, 0, m_document->tracksCount() - 1, 1, &ok);
2018         if (!ok) return;
2019     } else {
2020         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
2021         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight);
2022     }
2023     ClipItem *item = getClipItemAt(pos, track);
2024     if (item) {
2025         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);
2026         return;
2027     }
2028     int length = m_document->renderer()->mltGetSpaceLength(pos, m_document->tracksCount() - track, true);
2029     //kDebug() << "// GOT LENGT; " << length;
2030     if (length <= 0) {
2031         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);
2032         return;
2033     }
2034
2035     QRectF r(pos.frames(m_document->fps()), track * m_tracksHeight + m_tracksHeight / 2, sceneRect().width() - pos.frames(m_document->fps()), m_tracksHeight / 2 - 1);
2036     QList<QGraphicsItem *> items = m_scene->items(r);
2037
2038     QList<ItemInfo> clipsToMove;
2039     QList<ItemInfo> transitionsToMove;
2040
2041     for (int i = 0; i < items.count(); i++) {
2042         if (items.at(i)->type() == AVWIDGET || items.at(i)->type() == TRANSITIONWIDGET) {
2043             AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2044             ItemInfo info = item->info();
2045             if (item->type() == AVWIDGET) {
2046                 clipsToMove.append(info);
2047             } else if (item->type() == TRANSITIONWIDGET) {
2048                 transitionsToMove.append(info);
2049             }
2050         }
2051     }
2052
2053     InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, GenTime(-length, m_document->fps()), true);
2054     m_commandStack->push(command);
2055 }
2056
2057 void CustomTrackView::slotInsertSpace()
2058 {
2059     GenTime pos;
2060     int track = 0;
2061     if (m_menuPosition.isNull()) {
2062         pos = GenTime(cursorPos(), m_document->fps());
2063     } else {
2064         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
2065         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight) + 1;
2066     }
2067     SpacerDialog d(GenTime(65, m_document->fps()), m_document->timecode(), track, m_document->tracksCount(), this);
2068     if (d.exec() != QDialog::Accepted) return;
2069     GenTime spaceDuration = d.selectedDuration();
2070     track = d.selectedTrack();
2071     ClipItem *item = getClipItemAt(pos, track);
2072     if (item) pos = item->startPos();
2073
2074     int minh = 0;
2075     int maxh = sceneRect().height();
2076     if (track != -1) {
2077         minh = track * m_tracksHeight + m_tracksHeight / 2;
2078         maxh = m_tracksHeight / 2 - 1;
2079     }
2080
2081     QRectF r(pos.frames(m_document->fps()), minh, sceneRect().width() - pos.frames(m_document->fps()), maxh);
2082     QList<QGraphicsItem *> items = m_scene->items(r);
2083
2084     QList<ItemInfo> clipsToMove;
2085     QList<ItemInfo> transitionsToMove;
2086
2087     for (int i = 0; i < items.count(); i++) {
2088         if (items.at(i)->type() == AVWIDGET || items.at(i)->type() == TRANSITIONWIDGET) {
2089             AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2090             ItemInfo info = item->info();
2091             if (item->type() == AVWIDGET) {
2092                 clipsToMove.append(info);
2093             } else if (item->type() == TRANSITIONWIDGET) {
2094                 transitionsToMove.append(info);
2095             }
2096         }
2097     }
2098
2099     InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, spaceDuration, true);
2100     m_commandStack->push(command);
2101 }
2102
2103 void CustomTrackView::insertSpace(QList<ItemInfo> clipsToMove, QList<ItemInfo> transToMove, int track, const GenTime duration, const GenTime offset)
2104 {
2105     int diff = duration.frames(m_document->fps());
2106     resetSelectionGroup();
2107     m_selectionGroup = new AbstractGroupItem(m_document->fps());
2108     scene()->addItem(m_selectionGroup);
2109     ClipItem *clip;
2110     Transition *transition;
2111
2112     // Create lists with start pos for each track
2113     QMap <int, int> trackClipStartList;
2114     QMap <int, int> trackTransitionStartList;
2115
2116     for (int i = 1; i < m_document->tracksCount() + 1; i++) {
2117         trackClipStartList[i] = -1;
2118         trackTransitionStartList[i] = -1;
2119     }
2120
2121     if (!clipsToMove.isEmpty()) for (int i = 0; i < clipsToMove.count(); i++) {
2122             clip = getClipItemAtStart(clipsToMove.at(i).startPos + offset, clipsToMove.at(i).track);
2123             if (clip) {
2124                 if (clip->parentItem()) {
2125                     m_selectionGroup->addToGroup(clip->parentItem());
2126                     clip->parentItem()->setFlags(QGraphicsItem::ItemIsSelectable);
2127                 } else {
2128                     m_selectionGroup->addToGroup(clip);
2129                     clip->setFlags(QGraphicsItem::ItemIsSelectable);
2130                 }
2131                 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))
2132                     trackClipStartList[m_document->tracksCount() - clipsToMove.at(i).track] = clipsToMove.at(i).startPos.frames(m_document->fps());
2133             } 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);
2134         }
2135     if (!transToMove.isEmpty()) for (int i = 0; i < transToMove.count(); i++) {
2136             transition = getTransitionItemAtStart(transToMove.at(i).startPos + offset, transToMove.at(i).track);
2137             if (transition) {
2138                 if (transition->parentItem()) m_selectionGroup->addToGroup(transition->parentItem());
2139                 m_selectionGroup->addToGroup(transition);
2140                 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))
2141                     trackTransitionStartList[m_document->tracksCount() - transToMove.at(i).track] = transToMove.at(i).startPos.frames(m_document->fps());
2142                 transition->setFlags(QGraphicsItem::ItemIsSelectable);
2143             } 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);
2144         }
2145     m_selectionGroup->translate(diff, 0);
2146
2147     // update items coordinates
2148     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2149     for (int i = 0; i < itemList.count(); i++) {
2150         if (itemList.at(i)->type() == AVWIDGET || itemList.at(i)->type() == TRANSITIONWIDGET) {
2151             static_cast < AbstractClipItem *>(itemList.at(i))->updateItem();
2152         } else if (itemList.at(i)->type() == GROUPWIDGET) {
2153             QList<QGraphicsItem *> children = itemList.at(i)->childItems();
2154             for (int j = 0; j < children.count(); j++) {
2155                 static_cast < AbstractClipItem *>(children.at(j))->updateItem();
2156             }
2157         }
2158     }
2159     resetSelectionGroup(false);
2160     if (track != -1) track = m_document->tracksCount() - track;
2161     m_document->renderer()->mltInsertSpace(trackClipStartList, trackTransitionStartList, track, duration, offset);
2162 }
2163
2164 void CustomTrackView::deleteClip(const QString &clipId)
2165 {
2166     resetSelectionGroup();
2167     QList<QGraphicsItem *> itemList = items();
2168     QUndoCommand *deleteCommand = new QUndoCommand();
2169     deleteCommand->setText(i18n("Delete timeline clips"));
2170     int count = 0;
2171     for (int i = 0; i < itemList.count(); i++) {
2172         if (itemList.at(i)->type() == AVWIDGET) {
2173             ClipItem *item = (ClipItem *)itemList.at(i);
2174             if (item->clipProducer() == clipId) {
2175                 count++;
2176                 if (item->parentItem()) {
2177                     // Clip is in a group, destroy the group
2178                     new GroupClipsCommand(this, QList<ItemInfo>() << item->info(), QList<ItemInfo>(), false, deleteCommand);
2179                 }
2180                 new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true, deleteCommand);
2181             }
2182         }
2183     }
2184     if (count == 0) delete deleteCommand;
2185     else m_commandStack->push(deleteCommand);
2186 }
2187
2188 void CustomTrackView::setCursorPos(int pos, bool seek)
2189 {
2190     if (pos == m_cursorPos) return;
2191     emit cursorMoved((int)(m_cursorPos), (int)(pos));
2192     m_cursorPos = pos;
2193     if (seek) m_document->renderer()->seek(GenTime(m_cursorPos, m_document->fps()));
2194     else if (m_autoScroll) checkScrolling();
2195     m_cursorLine->setPos(m_cursorPos, 0);
2196 }
2197
2198 void CustomTrackView::updateCursorPos()
2199 {
2200     m_cursorLine->setPos(m_cursorPos, 0);
2201 }
2202
2203 int CustomTrackView::cursorPos()
2204 {
2205     return (int)(m_cursorPos);
2206 }
2207
2208 void CustomTrackView::moveCursorPos(int delta)
2209 {
2210     if (m_cursorPos + delta < 0) delta = 0 - m_cursorPos;
2211     emit cursorMoved((int)(m_cursorPos), (int)((m_cursorPos + delta)));
2212     m_cursorPos += delta;
2213     m_cursorLine->setPos(m_cursorPos, 0);
2214     m_document->renderer()->seek(GenTime(m_cursorPos, m_document->fps()));
2215 }
2216
2217 void CustomTrackView::initCursorPos(int pos)
2218 {
2219     emit cursorMoved((int)(m_cursorPos), (int)(pos));
2220     m_cursorPos = pos;
2221     m_cursorLine->setPos(pos, 0);
2222     checkScrolling();
2223 }
2224
2225 void CustomTrackView::checkScrolling()
2226 {
2227     ensureVisible(m_cursorPos, verticalScrollBar()->value() + 10, 2, 2, 50, 0);
2228 }
2229
2230 void CustomTrackView::mouseReleaseEvent(QMouseEvent * event)
2231 {
2232     if (m_moveOpMode == SEEK) m_moveOpMode = NONE;
2233     QGraphicsView::mouseReleaseEvent(event);
2234     if (m_scrollTimer.isActive()) m_scrollTimer.stop();
2235     if (event->button() == Qt::MidButton) {
2236         return;
2237     }
2238     setDragMode(QGraphicsView::NoDrag);
2239     if (m_operationMode == MOVEGUIDE) {
2240         setCursor(Qt::ArrowCursor);
2241         m_operationMode = NONE;
2242         m_dragGuide->setFlag(QGraphicsItem::ItemIsMovable, false);
2243         GenTime newPos = GenTime(m_dragGuide->pos().x(), m_document->fps());
2244         if (newPos != m_dragGuide->position()) {
2245             EditGuideCommand *command = new EditGuideCommand(this, m_dragGuide->position(), m_dragGuide->label(), newPos, m_dragGuide->label(), false);
2246             m_commandStack->push(command);
2247             m_dragGuide->updateGuide(GenTime(m_dragGuide->pos().x(), m_document->fps()));
2248             m_document->syncGuides(m_guides);
2249         }
2250         m_dragGuide = NULL;
2251         m_dragItem = NULL;
2252         return;
2253     } else if (m_operationMode == SPACER && m_selectionGroup) {
2254         int track;
2255         if (event->modifiers() != Qt::ControlModifier) {
2256             // We are moving all tracks
2257             track = -1;
2258         } else track = (int)(mapToScene(m_clickEvent).y() / m_tracksHeight);
2259         GenTime timeOffset = GenTime(m_selectionGroup->scenePos().x(), m_document->fps()) - m_selectionGroupInfo.startPos;
2260         if (timeOffset != GenTime()) {
2261             QList<QGraphicsItem *> items = m_selectionGroup->childItems();
2262
2263             QList<ItemInfo> clipsToMove;
2264             QList<ItemInfo> transitionsToMove;
2265
2266             // Create lists with start pos for each track
2267             QMap <int, int> trackClipStartList;
2268             QMap <int, int> trackTransitionStartList;
2269
2270             for (int i = 1; i < m_document->tracksCount() + 1; i++) {
2271                 trackClipStartList[i] = -1;
2272                 trackTransitionStartList[i] = -1;
2273             }
2274
2275             int max = items.count();
2276             for (int i = 0; i < max; i++) {
2277                 if (items.at(i)->type() == GROUPWIDGET)
2278                     items += static_cast <QGraphicsItemGroup *>(items.at(i))->childItems();
2279             }
2280
2281             for (int i = 0; i < items.count(); i++) {
2282                 if (items.at(i)->type() == AVWIDGET) {
2283                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2284                     ItemInfo info = item->info();
2285                     clipsToMove.append(info);
2286                     item->updateItem();
2287                     if (trackClipStartList.value(m_document->tracksCount() - info.track) == -1 || info.startPos.frames(m_document->fps()) < trackClipStartList.value(m_document->tracksCount() - info.track))
2288                         trackClipStartList[m_document->tracksCount() - info.track] = info.startPos.frames(m_document->fps());
2289                 } else if (items.at(i)->type() == TRANSITIONWIDGET) {
2290                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2291                     ItemInfo info = item->info();
2292                     transitionsToMove.append(info);
2293                     item->updateItem();
2294                     if (trackTransitionStartList.value(m_document->tracksCount() - info.track) == -1 || info.startPos.frames(m_document->fps()) < trackTransitionStartList.value(m_document->tracksCount() - info.track))
2295                         trackTransitionStartList[m_document->tracksCount() - info.track] = info.startPos.frames(m_document->fps());
2296                 }
2297             }
2298
2299             InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, timeOffset, false);
2300             m_commandStack->push(command);
2301             if (track != -1) track = m_document->tracksCount() - track;
2302             kDebug() << "SPACER TRACK:" << track;
2303             m_document->renderer()->mltInsertSpace(trackClipStartList, trackTransitionStartList, track, timeOffset, GenTime());
2304         }
2305         resetSelectionGroup(false);
2306         m_operationMode = NONE;
2307     } else if (m_operationMode == RUBBERSELECTION) {
2308         //kDebug() << "// END RUBBER SELECT";
2309         resetSelectionGroup();
2310         groupSelectedItems();
2311         m_operationMode = NONE;
2312     }
2313
2314     if (m_dragItem == NULL && m_selectionGroup == NULL) {
2315         emit transitionItemSelected(NULL);
2316         return;
2317     }
2318     ItemInfo info;
2319     if (m_dragItem) info = m_dragItem->info();
2320
2321     if (m_operationMode == MOVE) {
2322         setCursor(Qt::OpenHandCursor);
2323
2324         if (m_dragItem->parentItem() == 0) {
2325             // we are moving one clip, easy
2326             if (m_dragItem->type() == AVWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
2327                 ClipItem *item = static_cast <ClipItem *>(m_dragItem);
2328                 Mlt::Producer *prod;
2329                 if (item->isAudioOnly()) prod = item->baseClip()->audioProducer(m_dragItemInfo.track);
2330                 else if (item->isVideoOnly()) prod = item->baseClip()->videoProducer();
2331                 else prod = item->baseClip()->producer(m_dragItemInfo.track);
2332                 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())), prod);
2333                 if (success) {
2334                     kDebug() << "// get trans info";
2335                     int tracknumber = m_document->tracksCount() - item->track() - 1;
2336                     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2337                     if (isLocked) item->setItemLocked(true);
2338
2339                     QUndoCommand *moveCommand = new QUndoCommand();
2340                     moveCommand->setText(i18n("Move clip"));
2341                     new MoveClipCommand(this, m_dragItemInfo, info, false, moveCommand);
2342                     // Also move automatic transitions (on lower track)
2343                     Transition *tr = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track);
2344                     kDebug() << "// get trans info2";
2345                     if (tr && tr->isAutomatic()) {
2346                         ItemInfo trInfo = tr->info();
2347                         ItemInfo newTrInfo = trInfo;
2348                         newTrInfo.track = info.track;
2349                         newTrInfo.startPos = m_dragItem->startPos();
2350                         if (m_dragItemInfo.track == info.track && !item->baseClip()->isTransparent() && getClipItemAtEnd(newTrInfo.endPos, m_document->tracksCount() - tr->transitionEndTrack())) {
2351                             // transition end should stay the same
2352                         } else {
2353                             // transition end should be adjusted to clip
2354                             newTrInfo.endPos = newTrInfo.endPos + (newTrInfo.startPos - trInfo.startPos);
2355                         }
2356                         if (newTrInfo.startPos < newTrInfo.endPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2357                     }
2358                     if (tr == NULL || tr->endPos() < m_dragItemInfo.endPos) {
2359                         // Check if there is a transition at clip end
2360                         tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track);
2361                         if (tr && tr->isAutomatic()) {
2362                             ItemInfo trInfo = tr->info();
2363                             ItemInfo newTrInfo = trInfo;
2364                             newTrInfo.track = info.track;
2365                             newTrInfo.endPos = m_dragItem->endPos();
2366                             if (m_dragItemInfo.track == info.track && !item->baseClip()->isTransparent() && getClipItemAtStart(trInfo.startPos, m_document->tracksCount() - tr->transitionEndTrack())) {
2367                                 // transition start should stay the same
2368                             } else {
2369                                 // transition start should be moved
2370                                 newTrInfo.startPos = newTrInfo.startPos + (newTrInfo.endPos - trInfo.endPos);
2371                             }
2372                             if (newTrInfo.startPos < newTrInfo.endPos)
2373                                 new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2374                         }
2375                     }
2376                     // Also move automatic transitions (on upper track)
2377                     tr = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2378                     if (m_dragItemInfo.track == info.track && tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
2379                         ItemInfo trInfo = tr->info();
2380                         ItemInfo newTrInfo = trInfo;
2381                         newTrInfo.startPos = m_dragItem->startPos();
2382                         ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2383                         if (!upperClip || !upperClip->baseClip()->isTransparent()) {
2384                             if (!getClipItemAtEnd(newTrInfo.endPos, tr->track())) {
2385                                 // transition end should be adjusted to clip on upper track
2386                                 newTrInfo.endPos = newTrInfo.endPos + (newTrInfo.startPos - trInfo.startPos);
2387                             }
2388                             if (newTrInfo.startPos < newTrInfo.endPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2389                         }
2390                     }
2391                     if (m_dragItemInfo.track == info.track && (tr == NULL || tr->endPos() < m_dragItemInfo.endPos)) {
2392                         // Check if there is a transition at clip end
2393                         tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
2394                         if (tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
2395                             ItemInfo trInfo = tr->info();
2396                             ItemInfo newTrInfo = trInfo;
2397                             newTrInfo.endPos = m_dragItem->endPos();
2398                             ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2399                             if (!upperClip || !upperClip->baseClip()->isTransparent()) {
2400                                 if (!getClipItemAtStart(trInfo.startPos, tr->track())) {
2401                                     // transition start should be moved
2402                                     newTrInfo.startPos = newTrInfo.startPos + (newTrInfo.endPos - trInfo.endPos);
2403                                 }
2404                                 if (newTrInfo.startPos < newTrInfo.endPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2405                             }
2406                         }
2407                     }
2408                     m_commandStack->push(moveCommand);
2409                 } else {
2410                     // undo last move and emit error message
2411                     bool snap = KdenliveSettings::snaptopoints();
2412                     KdenliveSettings::setSnaptopoints(false);
2413                     item->setPos((int) m_dragItemInfo.startPos.frames(m_document->fps()), (int)(m_dragItemInfo.track * m_tracksHeight + 1));
2414                     KdenliveSettings::setSnaptopoints(snap);
2415                     emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(m_dragItemInfo.startPos.frames(m_document->fps()))), ErrorMessage);
2416                 }
2417                 setDocumentModified();
2418             }
2419             if (m_dragItem->type() == TRANSITIONWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
2420                 Transition *transition = static_cast <Transition *>(m_dragItem);
2421                 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)) {
2422                     // Moving transition failed, revert to previous position
2423                     emit displayMessage(i18n("Cannot move transition"), ErrorMessage);
2424                     transition->setPos((int) m_dragItemInfo.startPos.frames(m_document->fps()), (m_dragItemInfo.track) * m_tracksHeight + 1);
2425                 } else {
2426                     MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
2427                     m_commandStack->push(command);
2428                     transition->updateTransitionEndTrack(getPreviousVideoTrack(m_dragItem->track()));
2429                 }
2430             }
2431         } else {
2432             // Moving several clips. We need to delete them and readd them to new position,
2433             // or they might overlap each other during the move
2434             QGraphicsItemGroup *group = static_cast <QGraphicsItemGroup *>(m_dragItem->parentItem());
2435             QList<QGraphicsItem *> items = group->childItems();
2436
2437             QList<ItemInfo> clipsToMove;
2438             QList<ItemInfo> transitionsToMove;
2439
2440             GenTime timeOffset = GenTime(m_dragItem->scenePos().x(), m_document->fps()) - m_dragItemInfo.startPos;
2441             const int trackOffset = (int)(m_dragItem->scenePos().y() / m_tracksHeight) - m_dragItemInfo.track;
2442             //kDebug() << "// MOVED SEVERAL CLIPS" << timeOffset.frames(25);
2443             if (timeOffset != GenTime() || trackOffset != 0) {
2444                 // remove items in MLT playlist
2445
2446                 // Expand groups
2447                 int max = items.count();
2448                 for (int i = 0; i < max; i++) {
2449                     if (items.at(i)->type() == GROUPWIDGET) {
2450                         items += items.at(i)->childItems();
2451                     }
2452                 }
2453
2454                 for (int i = 0; i < items.count(); i++) {
2455                     if (items.at(i)->type() != AVWIDGET && items.at(i)->type() != TRANSITIONWIDGET) continue;
2456                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2457                     ItemInfo info = item->info();
2458                     if (item->type() == AVWIDGET) {
2459                         if (m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
2460                             // error, clip cannot be removed from playlist
2461                             emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
2462                         } else {
2463                             clipsToMove.append(info);
2464                         }
2465                     } else {
2466                         transitionsToMove.append(info);
2467                         Transition *tr = static_cast <Transition*>(item);
2468                         m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2469                     }
2470                 }
2471
2472                 for (int i = 0; i < items.count(); i++) {
2473                     // re-add items in correct place
2474                     if (items.at(i)->type() != AVWIDGET && items.at(i)->type() != TRANSITIONWIDGET) continue;
2475                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2476                     item->updateItem();
2477                     ItemInfo info = item->info();
2478                     int tracknumber = m_document->tracksCount() - info.track - 1;
2479                     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2480                     if (isLocked) {
2481                         group->removeFromGroup(item);
2482                         item->setItemLocked(true);
2483                     }
2484
2485                     if (item->type() == AVWIDGET) {
2486                         ClipItem *clip = static_cast <ClipItem*>(item);
2487                         info.track = m_document->tracksCount() - info.track;
2488                         Mlt::Producer *prod;
2489                         if (clip->isAudioOnly()) prod = clip->baseClip()->audioProducer(info.track);
2490                         else if (clip->isVideoOnly()) prod = clip->baseClip()->videoProducer();
2491                         else prod = clip->baseClip()->producer(info.track);
2492                         m_document->renderer()->mltInsertClip(info, clip->xml(), prod);
2493                         for (int i = 0; i < clip->effectsCount(); i++) {
2494                             m_document->renderer()->mltAddEffect(info.track, info.startPos, clip->getEffectArgs(clip->effectAt(i)), false);
2495                         }
2496                     } else {
2497                         Transition *tr = static_cast <Transition*>(item);
2498                         int newTrack = tr->transitionEndTrack();
2499                         if (!tr->forcedTrack()) {
2500                             newTrack = getPreviousVideoTrack(info.track);
2501                         }
2502                         tr->updateTransitionEndTrack(newTrack);
2503                         m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2504                     }
2505                 }
2506
2507                 MoveGroupCommand *move = new MoveGroupCommand(this, clipsToMove, transitionsToMove, timeOffset, trackOffset, false);
2508                 m_commandStack->push(move);
2509
2510                 //QPointF top = group->sceneBoundingRect().topLeft();
2511                 //QPointF oldpos = m_selectionGroup->scenePos();
2512                 //kDebug()<<"SELECTION GRP POS: "<<m_selectionGroup->scenePos()<<", TOP: "<<top;
2513                 //group->setPos(top);
2514                 //TODO: get rid of the 3 lines below
2515                 if (m_selectionGroup) {
2516                     m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
2517                     m_selectionGroupInfo.track = m_selectionGroup->track();
2518                 }
2519                 setDocumentModified();
2520             }
2521         }
2522         m_document->renderer()->doRefresh();
2523     } else if (m_operationMode == RESIZESTART && m_dragItem->startPos() != m_dragItemInfo.startPos) {
2524         // resize start
2525         if (m_dragItem->type() == AVWIDGET) {
2526             ItemInfo resizeinfo = m_dragItemInfo;
2527             resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
2528             bool success = m_document->renderer()->mltResizeClipStart(resizeinfo, m_dragItem->startPos() - m_dragItemInfo.startPos);
2529             if (success) {
2530                 QUndoCommand *resizeCommand = new QUndoCommand();
2531                 resizeCommand->setText(i18n("Resize clip"));
2532
2533                 // Check if there is an automatic transition on that clip (lower track)
2534                 Transition *transition = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track);
2535                 if (transition && transition->isAutomatic()) {
2536                     ItemInfo trInfo = transition->info();
2537                     ItemInfo newTrInfo = trInfo;
2538                     newTrInfo.startPos = m_dragItem->startPos();
2539                     if (newTrInfo.startPos < newTrInfo.endPos)
2540                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2541                 }
2542                 // Check if there is an automatic transition on that clip (upper track)
2543                 transition = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2544                 if (transition && transition->isAutomatic() && (m_document->tracksCount() - transition->transitionEndTrack()) == m_dragItemInfo.track) {
2545                     ItemInfo trInfo = transition->info();
2546                     ItemInfo newTrInfo = trInfo;
2547                     newTrInfo.startPos = m_dragItem->startPos();
2548                     ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2549                     if ((!upperClip || !upperClip->baseClip()->isTransparent()) && newTrInfo.startPos < newTrInfo.endPos) {
2550                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2551                     }
2552                 }
2553                 updateClipFade(static_cast <ClipItem *>(m_dragItem));
2554                 new ResizeClipCommand(this, m_dragItemInfo, info, false, resizeCommand);
2555                 m_commandStack->push(resizeCommand);
2556             } else {
2557                 m_dragItem->resizeStart((int) m_dragItemInfo.startPos.frames(m_document->fps()));
2558                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2559             }
2560         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
2561             Transition *transition = static_cast <Transition *>(m_dragItem);
2562             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)) {
2563                 // Cannot resize transition
2564                 transition->resizeStart((int) m_dragItemInfo.startPos.frames(m_document->fps()));
2565                 emit displayMessage(i18n("Cannot resize transition"), ErrorMessage);
2566             } else {
2567                 MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
2568                 m_commandStack->push(command);
2569             }
2570
2571         }
2572         if (m_dragItem->parentItem() && m_dragItem->parentItem() != m_selectionGroup) {
2573             // Item was resized, rebuild group;
2574             AbstractGroupItem *group = static_cast <AbstractGroupItem *>(m_dragItem->parentItem());
2575             QList <QGraphicsItem *> children = group->childItems();
2576             m_document->clipManager()->removeGroup(group);
2577             scene()->destroyItemGroup(group);
2578             for (int i = 0; i < children.count(); i++) {
2579                 children.at(i)->setSelected(true);
2580             }
2581             groupSelectedItems(false, true);
2582         }
2583         //m_document->renderer()->doRefresh();
2584     } else if (m_operationMode == RESIZEEND && m_dragItem->endPos() != m_dragItemInfo.endPos) {
2585         // resize end
2586         if (m_dragItem->type() == AVWIDGET) {
2587             ItemInfo resizeinfo = info;
2588             resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
2589             bool success = m_document->renderer()->mltResizeClipEnd(resizeinfo, resizeinfo.endPos - resizeinfo.startPos);
2590             if (success) {
2591                 QUndoCommand *resizeCommand = new QUndoCommand();
2592                 resizeCommand->setText(i18n("Resize clip"));
2593
2594                 // Check if there is an automatic transition on that clip (lower track)
2595                 Transition *tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track);
2596                 if (tr && tr->isAutomatic()) {
2597                     ItemInfo trInfo = tr->info();
2598                     ItemInfo newTrInfo = trInfo;
2599                     newTrInfo.endPos = m_dragItem->endPos();
2600                     if (newTrInfo.endPos > newTrInfo.startPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2601                 }
2602
2603                 // Check if there is an automatic transition on that clip (upper track)
2604                 tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
2605                 if (tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
2606                     ItemInfo trInfo = tr->info();
2607                     ItemInfo newTrInfo = trInfo;
2608                     newTrInfo.endPos = m_dragItem->endPos();
2609                     ClipItem * upperClip = getClipItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
2610                     if ((!upperClip || !upperClip->baseClip()->isTransparent()) && newTrInfo.endPos > newTrInfo.startPos) {
2611                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2612                     }
2613                 }
2614
2615                 new ResizeClipCommand(this, m_dragItemInfo, info, false, resizeCommand);
2616                 m_commandStack->push(resizeCommand);
2617                 updateClipFade(static_cast <ClipItem *>(m_dragItem));
2618             } else {
2619                 m_dragItem->resizeEnd((int) m_dragItemInfo.endPos.frames(m_document->fps()));
2620                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2621             }
2622         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
2623             Transition *transition = static_cast <Transition *>(m_dragItem);
2624             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)) {
2625                 // Cannot resize transition
2626                 transition->resizeEnd((int) m_dragItemInfo.endPos.frames(m_document->fps()));
2627                 emit displayMessage(i18n("Cannot resize transition"), ErrorMessage);
2628             } else {
2629                 MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
2630                 m_commandStack->push(command);
2631             }
2632         }
2633         if (m_dragItem->parentItem() && m_dragItem->parentItem() != m_selectionGroup) {
2634             // Item was resized, rebuild group;
2635             AbstractGroupItem *group = static_cast <AbstractGroupItem *>(m_dragItem->parentItem());
2636             QList <QGraphicsItem *> children = group->childItems();
2637             m_document->clipManager()->removeGroup(group);
2638             scene()->destroyItemGroup(group);
2639             for (int i = 0; i < children.count(); i++) {
2640                 children.at(i)->setSelected(true);
2641             }
2642             groupSelectedItems(false, true);
2643         }
2644         //m_document->renderer()->doRefresh();
2645     } else if (m_operationMode == FADEIN) {
2646         // resize fade in effect
2647         ClipItem * item = (ClipItem *) m_dragItem;
2648         int ix = item->hasEffect("volume", "fadein");
2649         if (ix != -1) {
2650             QDomElement oldeffect = item->effectAt(ix);
2651             int start = item->cropStart().frames(m_document->fps());
2652             int end = item->fadeIn();
2653             if (end == 0) {
2654                 slotDeleteEffect(item, oldeffect);
2655             } else {
2656                 end += start;
2657                 QDomElement effect = oldeffect.cloneNode().toElement();
2658                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2659                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2660                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2661                 emit clipItemSelected(item, ix);
2662             }
2663         } else if (item->fadeIn() != 0 && item->hasEffect("", "fade_from_black") == -1) {
2664             QDomElement effect = MainWindow::audioEffects.getEffectByTag("volume", "fadein").cloneNode().toElement();
2665             EffectsList::setParameter(effect, "out", QString::number(item->fadeIn()));
2666             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
2667         }
2668         ix = item->hasEffect("volume", "fade_from_black");
2669         if (ix != -1) {
2670             QDomElement oldeffect = item->effectAt(ix);
2671             int start = item->cropStart().frames(m_document->fps());
2672             int end = item->fadeIn();
2673             if (end == 0) {
2674                 slotDeleteEffect(item, oldeffect);
2675             } else {
2676                 end += start;
2677                 QDomElement effect = oldeffect.cloneNode().toElement();
2678                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2679                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2680                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2681                 emit clipItemSelected(item, ix);
2682             }
2683         }
2684     } else if (m_operationMode == FADEOUT) {
2685         // resize fade in effect
2686         ClipItem * item = (ClipItem *) m_dragItem;
2687         int ix = item->hasEffect("volume", "fadeout");
2688         if (ix != -1) {
2689             QDomElement oldeffect = item->effectAt(ix);
2690             int end = (item->cropDuration() + item->cropStart()).frames(m_document->fps());
2691             int start = item->fadeOut();
2692             if (start == 0) {
2693                 slotDeleteEffect(item, oldeffect);
2694             } else {
2695                 start = end - start;
2696                 QDomElement effect = oldeffect.cloneNode().toElement();
2697                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2698                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2699                 // kDebug()<<"EDIT FADE OUT : "<<start<<"x"<<end;
2700                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2701                 emit clipItemSelected(item, ix);
2702             }
2703         } else if (item->fadeOut() != 0 && item->hasEffect("", "fade_to_black") == -1) {
2704             QDomElement effect = MainWindow::audioEffects.getEffectByTag("volume", "fadeout").cloneNode().toElement();
2705             EffectsList::setParameter(effect, "in", QString::number(item->fadeOut()));
2706             EffectsList::setParameter(effect, "out", QString::number(0));
2707             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
2708         }
2709         ix = item->hasEffect("brightness", "fade_to_black");
2710         if (ix != -1) {
2711             QDomElement oldeffect = item->effectAt(ix);
2712             int end = (item->cropDuration() + item->cropStart()).frames(m_document->fps());
2713             int start = item->fadeOut();
2714             if (start == 0) {
2715                 slotDeleteEffect(item, oldeffect);
2716             } else {
2717                 start = end - start;
2718                 QDomElement effect = oldeffect.cloneNode().toElement();
2719                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2720                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2721                 // kDebug()<<"EDIT FADE OUT : "<<start<<"x"<<end;
2722                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2723                 emit clipItemSelected(item, ix);
2724             }
2725         }
2726     } else if (m_operationMode == KEYFRAME) {
2727         // update the MLT effect
2728         ClipItem * item = (ClipItem *) m_dragItem;
2729         QString previous = item->keyframes(item->selectedEffectIndex());
2730         item->updateKeyframeEffect();
2731         QString next = item->keyframes(item->selectedEffectIndex());
2732         EditKeyFrameCommand *command = new EditKeyFrameCommand(this, item->track(), item->startPos(), item->selectedEffectIndex(), previous, next, false);
2733         m_commandStack->push(command);
2734         updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
2735         emit clipItemSelected(item, item->selectedEffectIndex());
2736     }
2737     if (m_dragItem && m_dragItem->type() == TRANSITIONWIDGET && m_dragItem->isSelected()) {
2738         // A transition is selected
2739         QPoint p;
2740         ClipItem *transitionClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track);
2741         if (transitionClip && transitionClip->baseClip()) {
2742             QString size = transitionClip->baseClip()->getProperty("frame_size");
2743             p.setX(size.section('x', 0, 0).toInt());
2744             p.setY(size.section('x', 1, 1).toInt());
2745         }
2746         emit transitionItemSelected(static_cast <Transition *>(m_dragItem), getPreviousVideoTrack(m_dragItem->track()), p);
2747     } else emit transitionItemSelected(NULL);
2748     if (m_operationMode != NONE && m_operationMode != MOVE) setDocumentModified();
2749     m_operationMode = NONE;
2750 }
2751
2752 void CustomTrackView::deleteClip(ItemInfo info)
2753 {
2754     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
2755
2756     if (!item || m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
2757         emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
2758         return;
2759     }
2760     if (item->isSelected()) emit clipItemSelected(NULL);
2761     item->baseClip()->removeReference();
2762     m_document->updateClip(item->baseClip()->getId());
2763
2764     /*if (item->baseClip()->isTransparent()) {
2765         // also remove automatic transition
2766         Transition *tr = getTransitionItemAt(info.startPos, info.track);
2767         if (tr && tr->isAutomatic()) {
2768             m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2769             scene()->removeItem(tr);
2770             delete tr;
2771         }
2772     }*/
2773     scene()->removeItem(item);
2774     m_waitingThumbs.removeAll(item);
2775     if (m_dragItem == item) m_dragItem = NULL;
2776     delete item;
2777     item = NULL;
2778     setDocumentModified();
2779     m_document->renderer()->doRefresh();
2780 }
2781
2782 void CustomTrackView::deleteSelectedClips()
2783 {
2784     resetSelectionGroup();
2785     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2786     if (itemList.count() == 0) {
2787         emit displayMessage(i18n("Select clip to delete"), ErrorMessage);
2788         return;
2789     }
2790     scene()->clearSelection();
2791     QUndoCommand *deleteSelected = new QUndoCommand();
2792     deleteSelected->setText(i18n("Delete selected items"));
2793     bool resetGroup = false;
2794
2795     // expand & destroy groups
2796     for (int i = 0; i < itemList.count(); i++) {
2797         if (itemList.at(i)->type() == GROUPWIDGET) {
2798             QList<QGraphicsItem *> children = itemList.at(i)->childItems();
2799             itemList += children;
2800             QList <ItemInfo> clipInfos;
2801             QList <ItemInfo> transitionInfos;
2802             GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
2803             for (int j = 0; j < children.count(); j++) {
2804                 if (children.at(j)->type() == AVWIDGET) {
2805                     AbstractClipItem *clip = static_cast <AbstractClipItem *>(children.at(j));
2806                     if (!clip->isItemLocked()) clipInfos.append(clip->info());
2807                 } else if (children.at(j)->type() == TRANSITIONWIDGET) {
2808                     AbstractClipItem *clip = static_cast <AbstractClipItem *>(children.at(j));
2809                     if (!clip->isItemLocked()) transitionInfos.append(clip->info());
2810                 }
2811             }
2812             if (clipInfos.count() > 0) {
2813                 new GroupClipsCommand(this, clipInfos, transitionInfos, false, deleteSelected);
2814             }
2815         }
2816     }
2817
2818     for (int i = 0; i < itemList.count(); i++) {
2819         if (itemList.at(i)->type() == AVWIDGET) {
2820             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2821             if (item->parentItem()) resetGroup = true;
2822             //kDebug()<<"// DELETE CLP AT: "<<item->info().startPos.frames(25);
2823             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true, deleteSelected);
2824             emit clipItemSelected(NULL);
2825         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
2826             Transition *item = static_cast <Transition *>(itemList.at(i));
2827             //kDebug()<<"// DELETE TRANS AT: "<<item->info().startPos.frames(25);
2828             if (item->parentItem()) resetGroup = true;
2829             new AddTransitionCommand(this, item->info(), item->transitionEndTrack(), item->toXML(), true, true, deleteSelected);
2830             emit transitionItemSelected(NULL);
2831         }
2832     }
2833
2834     m_commandStack->push(deleteSelected);
2835 }
2836
2837 void CustomTrackView::changeClipSpeed()
2838 {
2839     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2840     if (itemList.count() == 0) {
2841         emit displayMessage(i18n("Select clip to change speed"), ErrorMessage);
2842         return;
2843     }
2844     QUndoCommand *changeSelected = new QUndoCommand();
2845     changeSelected->setText("Edit clip speed");
2846     int count = 0;
2847     int percent = -1;
2848     bool ok;
2849     for (int i = 0; i < itemList.count(); i++) {
2850         if (itemList.at(i)->type() == AVWIDGET) {
2851             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2852             ItemInfo info = item->info();
2853             if (percent == -1) percent = QInputDialog::getInteger(this, i18n("Edit Clip Speed"), i18n("New speed (percents)"), item->speed() * 100, 1, 10000, 1, &ok);
2854             if (!ok) break;
2855             double speed = (double) percent / 100.0;
2856             if (item->speed() != speed && (item->clipType() == VIDEO || item->clipType() == AV)) {
2857                 count++;
2858                 new ChangeSpeedCommand(this, info, item->speed(), speed, item->clipProducer(), changeSelected);
2859             }
2860         }
2861     }
2862     if (count > 0) m_commandStack->push(changeSelected);
2863     else delete changeSelected;
2864 }
2865
2866 void CustomTrackView::doChangeClipSpeed(ItemInfo info, const double speed, const double oldspeed, const QString &id)
2867 {
2868     DocClipBase *baseclip = m_document->clipManager()->getClipById(id);
2869     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
2870     if (!item) {
2871         kDebug() << "ERROR: Cannot find clip for speed change";
2872         emit displayMessage(i18n("Cannot find clip for speed change"), ErrorMessage);
2873         return;
2874     }
2875     info.track = m_document->tracksCount() - item->track();
2876     int endPos = m_document->renderer()->mltChangeClipSpeed(info, speed, oldspeed, baseclip->producer());
2877     if (endPos >= 0) {
2878         item->setSpeed(speed);
2879         item->updateRectGeometry();
2880         if (item->cropDuration().frames(m_document->fps()) > endPos)
2881             item->AbstractClipItem::resizeEnd(info.startPos.frames(m_document->fps()) + endPos, speed);
2882         setDocumentModified();
2883     } else emit displayMessage(i18n("Invalid clip"), ErrorMessage);
2884 }
2885
2886 void CustomTrackView::cutSelectedClips()
2887 {
2888     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2889     GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
2890     for (int i = 0; i < itemList.count(); i++) {
2891         if (itemList.at(i)->type() == AVWIDGET) {
2892             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2893             if (item->parentItem() && item->parentItem() != m_selectionGroup) {
2894                 emit displayMessage(i18n("Cannot cut a clip in a group"), ErrorMessage);
2895             } else if (currentPos > item->startPos() && currentPos <  item->endPos()) {
2896                 RazorClipCommand *command = new RazorClipCommand(this, item->info(), currentPos);
2897                 m_commandStack->push(command);
2898             }
2899         }
2900     }
2901 }
2902
2903 void CustomTrackView::groupClips(bool group)
2904 {
2905     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2906     QList <ItemInfo> clipInfos;
2907     QList <ItemInfo> transitionInfos;
2908     GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
2909
2910     // Expand groups
2911     int max = itemList.count();
2912     for (int i = 0; i < max; i++) {
2913         if (itemList.at(i)->type() == GROUPWIDGET) {
2914             itemList += itemList.at(i)->childItems();
2915         }
2916     }
2917
2918     for (int i = 0; i < itemList.count(); i++) {
2919         if (itemList.at(i)->type() == AVWIDGET) {
2920             AbstractClipItem *clip = static_cast <AbstractClipItem *>(itemList.at(i));
2921             if (!clip->isItemLocked()) clipInfos.append(clip->info());
2922         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
2923             AbstractClipItem *clip = static_cast <AbstractClipItem *>(itemList.at(i));
2924             if (!clip->isItemLocked()) transitionInfos.append(clip->info());
2925         }
2926     }
2927     if (clipInfos.count() > 0) {
2928         GroupClipsCommand *command = new GroupClipsCommand(this, clipInfos, transitionInfos, group);
2929         m_commandStack->push(command);
2930     }
2931 }
2932
2933 void CustomTrackView::doGroupClips(QList <ItemInfo> clipInfos, QList <ItemInfo> transitionInfos, bool group)
2934 {
2935     resetSelectionGroup();
2936     m_scene->clearSelection();
2937     if (!group) {
2938         for (int i = 0; i < clipInfos.count(); i++) {
2939             ClipItem *clip = getClipItemAt(clipInfos.at(i).startPos, clipInfos.at(i).track);
2940             if (clip == NULL) continue;
2941             if (clip->parentItem() && clip->parentItem()->type() == GROUPWIDGET) {
2942                 AbstractGroupItem *grp = static_cast <AbstractGroupItem *>(clip->parentItem());
2943                 m_document->clipManager()->removeGroup(grp);
2944                 scene()->destroyItemGroup(grp);
2945             }
2946             clip->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
2947         }
2948         for (int i = 0; i < transitionInfos.count(); i++) {
2949             Transition *tr = getTransitionItemAt(transitionInfos.at(i).startPos, transitionInfos.at(i).track);
2950             if (tr == NULL) continue;
2951             if (tr->parentItem() && tr->parentItem()->type() == GROUPWIDGET) {
2952                 AbstractGroupItem *grp = static_cast <AbstractGroupItem *>(tr->parentItem());
2953                 m_document->clipManager()->removeGroup(grp);
2954                 scene()->destroyItemGroup(grp);
2955             }
2956             tr->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
2957         }
2958         setDocumentModified();
2959         return;
2960     }
2961
2962     QList <QGraphicsItemGroup *> groups;
2963     for (int i = 0; i < clipInfos.count(); i++) {
2964         ClipItem *clip = getClipItemAt(clipInfos.at(i).startPos, clipInfos.at(i).track);
2965         if (clip) {
2966             clip->setSelected(true);
2967         }
2968     }
2969     for (int i = 0; i < transitionInfos.count(); i++) {
2970         Transition *clip = getTransitionItemAt(transitionInfos.at(i).startPos, transitionInfos.at(i).track);
2971         if (clip) {
2972             clip->setSelected(true);
2973         }
2974     }
2975
2976     groupSelectedItems(false, true);
2977     setDocumentModified();
2978 }
2979
2980 void CustomTrackView::addClip(QDomElement xml, const QString &clipId, ItemInfo info, EffectsList effects)
2981 {
2982     DocClipBase *baseclip = m_document->clipManager()->getClipById(clipId);
2983     if (baseclip == NULL) {
2984         emit displayMessage(i18n("No clip copied"), ErrorMessage);
2985         return;
2986     }
2987     ClipItem *item = new ClipItem(baseclip, info, m_document->fps(), xml.attribute("speed", "1").toDouble());
2988     item->setEffectList(effects);
2989     if (xml.hasAttribute("audio_only")) item->setAudioOnly(true);
2990     else if (xml.hasAttribute("video_only")) item->setVideoOnly(true);
2991     scene()->addItem(item);
2992
2993     int tracknumber = m_document->tracksCount() - info.track - 1;
2994     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2995     if (isLocked) item->setItemLocked(true);
2996
2997     baseclip->addReference();
2998     m_document->updateClip(baseclip->getId());
2999     info.track = m_document->tracksCount() - info.track;
3000     Mlt::Producer *prod;
3001     if (item->isAudioOnly()) prod = baseclip->audioProducer(info.track);
3002     else if (item->isVideoOnly()) prod = baseclip->videoProducer();
3003     else prod = baseclip->producer(info.track);
3004     m_document->renderer()->mltInsertClip(info, xml, prod);
3005     for (int i = 0; i < item->effectsCount(); i++) {
3006         m_document->renderer()->mltAddEffect(info.track, info.startPos, item->getEffectArgs(item->effectAt(i)), false);
3007     }
3008     setDocumentModified();
3009     m_document->renderer()->doRefresh();
3010     m_waitingThumbs.append(item);
3011     m_thumbsTimer.start();
3012 }
3013
3014 void CustomTrackView::slotUpdateClip(const QString &clipId)
3015 {
3016     QList<QGraphicsItem *> list = scene()->items();
3017     ClipItem *clip = NULL;
3018     for (int i = 0; i < list.size(); ++i) {
3019         if (list.at(i)->type() == AVWIDGET) {
3020             clip = static_cast <ClipItem *>(list.at(i));
3021             if (clip->clipProducer() == clipId) {
3022                 ItemInfo info = clip->info();
3023                 info.track = m_document->tracksCount() - clip->track();
3024                 m_document->renderer()->mltUpdateClip(info, clip->xml(), clip->baseClip()->producer());
3025                 clip->refreshClip(true);
3026                 clip->update();
3027             }
3028         }
3029     }
3030 }
3031
3032 ClipItem *CustomTrackView::getClipItemAtEnd(GenTime pos, int track)
3033 {
3034     int framepos = (int)(pos.frames(m_document->fps()));
3035     QList<QGraphicsItem *> list = scene()->items(QPointF(framepos - 1, track * m_tracksHeight + m_tracksHeight / 2));
3036     ClipItem *clip = NULL;
3037     for (int i = 0; i < list.size(); i++) {
3038         if (list.at(i)->type() == AVWIDGET) {
3039             ClipItem *test = static_cast <ClipItem *>(list.at(i));
3040             if (test->endPos() == pos) clip = test;
3041             break;
3042         }
3043     }
3044     return clip;
3045 }
3046
3047 ClipItem *CustomTrackView::getClipItemAtStart(GenTime pos, int track)
3048 {
3049     QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), track * m_tracksHeight + m_tracksHeight / 2));
3050     ClipItem *clip = NULL;
3051     for (int i = 0; i < list.size(); i++) {
3052         if (list.at(i)->type() == AVWIDGET) {
3053             ClipItem *test = static_cast <ClipItem *>(list.at(i));
3054             if (test->startPos() == pos) clip = test;
3055             break;
3056         }
3057     }
3058     return clip;
3059 }
3060
3061 ClipItem *CustomTrackView::getClipItemAt(int pos, int track)
3062 {
3063     QList<QGraphicsItem *> list = scene()->items(QPointF(pos, track * m_tracksHeight + m_tracksHeight / 2));
3064     ClipItem *clip = NULL;
3065     for (int i = 0; i < list.size(); i++) {
3066         if (list.at(i)->type() == AVWIDGET) {
3067             clip = static_cast <ClipItem *>(list.at(i));
3068             break;
3069         }
3070     }
3071     return clip;
3072 }
3073
3074 ClipItem *CustomTrackView::getClipItemAt(GenTime pos, int track)
3075 {
3076     int framepos = (int)(pos.frames(m_document->fps()));
3077     return getClipItemAt(framepos, track);
3078 }
3079
3080 Transition *CustomTrackView::getTransitionItemAt(int pos, int track)
3081 {
3082     QList<QGraphicsItem *> list = scene()->items(QPointF(pos, (track + 1) * m_tracksHeight));
3083     Transition *clip = NULL;
3084     for (int i = 0; i < list.size(); i++) {
3085         if (list.at(i)->type() == TRANSITIONWIDGET) {
3086             clip = static_cast <Transition *>(list.at(i));
3087             break;
3088         }
3089     }
3090     return clip;
3091 }
3092
3093 Transition *CustomTrackView::getTransitionItemAt(GenTime pos, int track)
3094 {
3095     return getTransitionItemAt(pos.frames(m_document->fps()), track);
3096 }
3097
3098 Transition *CustomTrackView::getTransitionItemAtEnd(GenTime pos, int track)
3099 {
3100     int framepos = (int)(pos.frames(m_document->fps()));
3101     QList<QGraphicsItem *> list = scene()->items(QPointF(framepos - 1, (track + 1) * m_tracksHeight));
3102     Transition *clip = NULL;
3103     for (int i = 0; i < list.size(); i++) {
3104         if (list.at(i)->type() == TRANSITIONWIDGET) {
3105             Transition *test = static_cast <Transition *>(list.at(i));
3106             if (test->endPos() == pos) clip = test;
3107             break;
3108         }
3109     }
3110     return clip;
3111 }
3112
3113 Transition *CustomTrackView::getTransitionItemAtStart(GenTime pos, int track)
3114 {
3115     QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), (track + 1) * m_tracksHeight));
3116     Transition *clip = NULL;
3117     for (int i = 0; i < list.size(); ++i) {
3118         if (list.at(i)->type() == TRANSITIONWIDGET) {
3119             Transition *test = static_cast <Transition *>(list.at(i));
3120             if (test->startPos() == pos) clip = test;
3121             break;
3122         }
3123     }
3124     return clip;
3125 }
3126
3127 void CustomTrackView::moveClip(const ItemInfo start, const ItemInfo end)
3128 {
3129     if (m_selectionGroup) resetSelectionGroup(false);
3130     ClipItem *item = getClipItemAt((int) start.startPos.frames(m_document->fps()) + 1, start.track);
3131     if (!item) {
3132         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);
3133         kDebug() << "----------------  ERROR, CANNOT find clip to move at.. ";
3134         return;
3135     }
3136     Mlt::Producer *prod;
3137     if (item->isAudioOnly()) prod = item->baseClip()->audioProducer(end.track);
3138     else if (item->isVideoOnly()) prod = item->baseClip()->videoProducer();
3139     else prod = item->baseClip()->producer(end.track);
3140
3141     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()), prod);
3142     if (success) {
3143         bool snap = KdenliveSettings::snaptopoints();
3144         KdenliveSettings::setSnaptopoints(false);
3145         item->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
3146
3147         int tracknumber = m_document->tracksCount() - end.track - 1;
3148         bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
3149         m_scene->clearSelection();
3150         if (isLocked) item->setItemLocked(true);
3151         else {
3152             if (item->isItemLocked()) item->setItemLocked(false);
3153             item->setSelected(true);
3154         }
3155         if (item->baseClip()->isTransparent()) {
3156             // Also move automatic transition
3157             Transition *tr = getTransitionItemAt(start.startPos, start.track);
3158             if (tr && tr->isAutomatic()) {
3159                 tr->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
3160                 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);
3161                 tr->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
3162             }
3163         }
3164         KdenliveSettings::setSnaptopoints(snap);
3165         setDocumentModified();
3166     } else {
3167         // undo last move and emit error message
3168         emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(end.startPos.frames(m_document->fps()))), ErrorMessage);
3169     }
3170     m_document->renderer()->doRefresh();
3171     //kDebug() << " // MOVED CLIP TO: " << end.startPos.frames(25) << ", ITEM START: " << item->startPos().frames(25);
3172 }
3173
3174 void CustomTrackView::moveGroup(QList <ItemInfo> startClip, QList <ItemInfo> startTransition, const GenTime offset, const int trackOffset, bool reverseMove)
3175 {
3176     // Group Items
3177     /*kDebug() << "//GRP MOVE, REVERS:" << reverseMove;
3178     kDebug() << "// GROUP MOV; OFFSET: " << offset.frames(25) << ", TK OFF: " << trackOffset;*/
3179     resetSelectionGroup();
3180     m_scene->clearSelection();
3181
3182     for (int i = 0; i < startClip.count(); i++) {
3183         if (reverseMove) {
3184             startClip[i].startPos = startClip.at(i).startPos - offset;
3185             startClip[i].track = startClip.at(i).track - trackOffset;
3186         }
3187         //kDebug()<<"//LKING FR CLIP AT:"<<startClip.at(i).startPos.frames(25)<<", TK:"<<startClip.at(i).track;
3188         ClipItem *clip = getClipItemAt(startClip.at(i).startPos, startClip.at(i).track);
3189         if (clip) {
3190             clip->setItemLocked(false);
3191             if (clip->parentItem()) clip->parentItem()->setSelected(true);
3192             else clip->setSelected(true);
3193             m_document->renderer()->mltRemoveClip(m_document->tracksCount() - startClip.at(i).track, startClip.at(i).startPos);
3194         } else kDebug() << "//MISSING CLIP AT: " << startClip.at(i).startPos.frames(25);
3195     }
3196     for (int i = 0; i < startTransition.count(); i++) {
3197         if (reverseMove) {
3198             startTransition[i].startPos = startTransition.at(i).startPos - offset;
3199             startTransition[i].track = startTransition.at(i).track - trackOffset;
3200         }
3201         Transition *tr = getTransitionItemAt(startTransition.at(i).startPos, startTransition.at(i).track);
3202         if (tr) {
3203             tr->setItemLocked(false);
3204             if (tr->parentItem()) tr->parentItem()->setSelected(true);
3205             else tr->setSelected(true);
3206             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());
3207         } else kDebug() << "//MISSING TRANSITION AT: " << startTransition.at(i).startPos.frames(25);
3208     }
3209     groupSelectedItems(true);
3210     if (m_selectionGroup) {
3211         bool snap = KdenliveSettings::snaptopoints();
3212         KdenliveSettings::setSnaptopoints(false);
3213
3214         m_selectionGroup->moveBy(offset.frames(m_document->fps()), trackOffset *(qreal) m_tracksHeight);
3215
3216         kDebug() << "%% GRP NEW POS: " << m_selectionGroup->scenePos().x();
3217
3218         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
3219         // Expand groups
3220         int max = children.count();
3221         for (int i = 0; i < max; i++) {
3222             if (children.at(i)->type() == GROUPWIDGET) {
3223                 children += children.at(i)->childItems();
3224             }
3225         }
3226         kDebug() << "// GRP MOVE; FOUND CHILDREN:" << children.count();
3227
3228         for (int i = 0; i < children.count(); i++) {
3229             // re-add items in correct place
3230             if (children.at(i)->type() != AVWIDGET && children.at(i)->type() != TRANSITIONWIDGET) continue;
3231             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
3232             item->updateItem();
3233             ItemInfo info = item->info();
3234             int tracknumber = m_document->tracksCount() - info.track - 1;
3235             bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
3236             if (isLocked) item->setItemLocked(true);
3237             else if (item->isItemLocked()) item->setItemLocked(false);
3238
3239             if (item->type() == AVWIDGET) {
3240                 ClipItem *clip = static_cast <ClipItem*>(item);
3241                 info.track = m_document->tracksCount() - info.track;
3242                 Mlt::Producer *prod;
3243                 if (clip->isAudioOnly()) prod = clip->baseClip()->audioProducer(info.track);
3244                 else if (clip->isVideoOnly()) prod = clip->baseClip()->videoProducer();
3245                 else prod = clip->baseClip()->producer(info.track);
3246                 m_document->renderer()->mltInsertClip(info, clip->xml(), prod);
3247                 kDebug() << "// inserting new clp: " << info.startPos.frames(25);
3248             } else if (item->type() == TRANSITIONWIDGET) {
3249                 Transition *tr = static_cast <Transition*>(item);
3250                 int newTrack = tr->transitionEndTrack();
3251                 kDebug() << "/// TRANSITION CURR TRK: " << newTrack;
3252                 if (!tr->forcedTrack()) {
3253                     newTrack += trackOffset;
3254                     if (newTrack < 0 || newTrack > m_document->tracksCount()) newTrack = getPreviousVideoTrack(info.track);
3255                 }
3256                 tr->updateTransitionEndTrack(newTrack);
3257                 kDebug() << "/// TRANSITION UPDATED TRK: " << newTrack;
3258                 m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
3259             }
3260         }
3261         KdenliveSettings::setSnaptopoints(snap);
3262         m_document->renderer()->doRefresh();
3263     } else kDebug() << "///////// WARNING; NO GROUP TO MOVE";
3264 }
3265
3266 void CustomTrackView::moveTransition(const ItemInfo start, const ItemInfo end)
3267 {
3268     Transition *item = getTransitionItemAt(start.startPos, start.track);
3269     if (!item) {
3270         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);
3271         kDebug() << "----------------  ERROR, CANNOT find transition to move... ";// << startPos.x() * m_scale * FRAME_SIZE + 1 << ", " << startPos.y() * m_tracksHeight + m_tracksHeight / 2;
3272         return;
3273     }
3274     //kDebug() << "----------------  Move TRANSITION FROM: " << startPos.x() << ", END:" << endPos.x() << ",TRACKS: " << oldtrack << " TO " << newtrack;
3275     bool snap = KdenliveSettings::snaptopoints();
3276     KdenliveSettings::setSnaptopoints(false);
3277     //kDebug()<<"///  RESIZE TRANS START: ("<< startPos.x()<<"x"<< startPos.y()<<") / ("<<endPos.x()<<"x"<< endPos.y()<<")";
3278     if (end.endPos - end.startPos == start.endPos - start.startPos) {
3279         // Transition was moved
3280         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
3281     } else if (end.endPos == start.endPos) {
3282         // Transition start resize
3283         item->resizeStart((int) end.startPos.frames(m_document->fps()));
3284     } else if (end.startPos == start.startPos) {
3285         // Transition end resize;
3286         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
3287     } else {
3288         // Move & resize
3289         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
3290         item->resizeStart((int) end.startPos.frames(m_document->fps()));
3291         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
3292     }
3293     //item->moveTransition(GenTime((int) (endPos.x() - startPos.x()), m_document->fps()));
3294     KdenliveSettings::setSnaptopoints(snap);
3295     item->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
3296     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);
3297     if (m_dragItem && m_dragItem == item) {
3298         QPoint p;
3299         ClipItem *transitionClip = getClipItemAt(item->startPos(), item->track());
3300         if (transitionClip && transitionClip->baseClip()) {
3301             QString size = transitionClip->baseClip()->getProperty("frame_size");
3302             p.setX(size.section('x', 0, 0).toInt());
3303             p.setY(size.section('x', 1, 1).toInt());
3304         }
3305         emit transitionItemSelected(item, getPreviousVideoTrack(item->track()), p);
3306     }
3307     m_document->renderer()->doRefresh();
3308 }
3309
3310 void CustomTrackView::resizeClip(const ItemInfo start, const ItemInfo end)
3311 {
3312     bool resizeClipStart = true;
3313     if (start.startPos == end.startPos) resizeClipStart = false;
3314     /*if (resizeClipStart) offset = 1;
3315     else offset = -1;*/
3316     ClipItem *item = getClipItemAt((int)(start.startPos.frames(m_document->fps())), start.track);
3317     if (!item) {
3318         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);
3319         kDebug() << "----------------  ERROR, CANNOT find clip to resize at... "; // << startPos;
3320         return;
3321     }
3322     if (item->parentItem()) {
3323         // Item is part of a group, reset group
3324         resetSelectionGroup();
3325     }
3326     bool snap = KdenliveSettings::snaptopoints();
3327     KdenliveSettings::setSnaptopoints(false);
3328     if (resizeClipStart && start.startPos != end.startPos) {
3329         ItemInfo clipinfo = item->info();
3330         clipinfo.track = m_document->tracksCount() - clipinfo.track;
3331         bool success = m_document->renderer()->mltResizeClipStart(clipinfo, end.startPos - item->startPos());
3332         if (success) {
3333             kDebug() << "RESIZE CLP STRAT TO:" << end.startPos.frames(m_document->fps()) << ", OLD ST: " << start.startPos.frames(25);
3334             item->resizeStart((int) end.startPos.frames(m_document->fps()));
3335             updateClipFade(item);
3336         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
3337     } else if (!resizeClipStart) {
3338         ItemInfo clipinfo = item->info();
3339         clipinfo.track = m_document->tracksCount() - clipinfo.track;
3340         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, end.endPos - clipinfo.startPos);
3341         if (success) {
3342             item->resizeEnd((int) end.endPos.frames(m_document->fps()));
3343             updateClipFade(item);
3344         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
3345     }
3346     if (end.cropStart != start.cropStart) {
3347         kDebug() << "// RESIZE CROP, DIFF: " << (end.cropStart - start.cropStart).frames(25);
3348         ItemInfo clipinfo = end;
3349         clipinfo.track = m_document->tracksCount() - end.track;
3350         bool success = m_document->renderer()->mltResizeClipCrop(clipinfo, end.cropStart - start.cropStart);
3351         if (success) {
3352             item->setCropStart(end.cropStart);
3353             item->resetThumbs(true);
3354         }
3355     }
3356     m_document->renderer()->doRefresh();
3357     KdenliveSettings::setSnaptopoints(snap);
3358 }
3359
3360 void CustomTrackView::updateClipFade(ClipItem * item)
3361 {
3362     int end = item->fadeIn();
3363     if (end != 0) {
3364         // there is a fade in effect
3365         int effectPos = item->hasEffect("volume", "fadein");
3366         if (effectPos != -1) {
3367             QDomElement oldeffect = item->effectAt(effectPos);
3368             int start = item->cropStart().frames(m_document->fps());
3369             int max = item->cropDuration().frames(m_document->fps());
3370             if (end > max) {
3371                 // Make sure the fade effect is not longer than the clip
3372                 item->setFadeIn(max);
3373                 end = item->fadeIn();
3374             }
3375             end += start;
3376             EffectsList::setParameter(oldeffect, "in", QString::number(start));
3377             EffectsList::setParameter(oldeffect, "out", QString::number(end));
3378             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3379                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3380             // if fade effect is displayed, update the effect edit widget with new clip duration
3381             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3382         }
3383         effectPos = item->hasEffect("brightness", "fade_from_black");
3384         if (effectPos != -1) {
3385             QDomElement oldeffect = item->effectAt(effectPos);
3386             int start = item->cropStart().frames(m_document->fps());
3387             int max = item->cropDuration().frames(m_document->fps());
3388             if (end > max) {
3389                 // Make sure the fade effect is not longer than the clip
3390                 item->setFadeIn(max);
3391                 end = item->fadeIn();
3392             }
3393             end += start;
3394             EffectsList::setParameter(oldeffect, "in", QString::number(start));
3395             EffectsList::setParameter(oldeffect, "out", QString::number(end));
3396             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3397                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3398             // if fade effect is displayed, update the effect edit widget with new clip duration
3399             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3400         }
3401     }
3402     int start = item->fadeOut();
3403     if (start != 0) {
3404         // there is a fade out effect
3405         int effectPos = item->hasEffect("volume", "fadeout");
3406         if (effectPos != -1) {
3407             QDomElement oldeffect = item->effectAt(effectPos);
3408             int max = item->cropDuration().frames(m_document->fps());
3409             int end = max + item->cropStart().frames(m_document->fps());
3410             if (start > max) {
3411                 // Make sure the fade effect is not longer than the clip
3412                 item->setFadeOut(max);
3413                 start = item->fadeOut();
3414             }
3415             start = end - start;
3416             EffectsList::setParameter(oldeffect, "in", QString::number(start));
3417             EffectsList::setParameter(oldeffect, "out", QString::number(end));
3418             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3419                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3420             // if fade effect is displayed, update the effect edit widget with new clip duration
3421             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3422         }
3423         effectPos = item->hasEffect("brightness", "fade_to_black");
3424         if (effectPos != -1) {
3425             QDomElement oldeffect = item->effectAt(effectPos);
3426             int max = item->cropDuration().frames(m_document->fps());
3427             int end = max + item->cropStart().frames(m_document->fps());
3428             if (start > max) {
3429                 // Make sure the fade effect is not longer than the clip
3430                 item->setFadeOut(max);
3431                 start = item->fadeOut();
3432             }
3433             start = end - start;
3434             EffectsList::setParameter(oldeffect, "in", QString::number(start));
3435             EffectsList::setParameter(oldeffect, "out", QString::number(end));
3436             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3437                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3438             // if fade effect is displayed, update the effect edit widget with new clip duration
3439             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3440         }
3441     }
3442 }
3443
3444 double CustomTrackView::getSnapPointForPos(double pos)
3445 {
3446     return m_scene->getSnapPointForPos(pos, KdenliveSettings::snaptopoints());
3447 }
3448
3449 void CustomTrackView::updateSnapPoints(AbstractClipItem *selected, QList <GenTime> offsetList, bool skipSelectedItems)
3450 {
3451     QList <GenTime> snaps;
3452     if (selected && offsetList.isEmpty()) offsetList.append(selected->cropDuration());
3453     QList<QGraphicsItem *> itemList = items();
3454     for (int i = 0; i < itemList.count(); i++) {
3455         if (itemList.at(i) == selected) continue;
3456         if (skipSelectedItems && itemList.at(i)->isSelected()) continue;
3457         if (itemList.at(i)->type() == AVWIDGET) {
3458             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
3459             GenTime start = item->startPos();
3460             GenTime end = item->endPos();
3461             snaps.append(start);
3462             snaps.append(end);
3463             if (!offsetList.isEmpty()) {
3464                 for (int j = 0; j < offsetList.size(); j++) {
3465                     if (start > offsetList.at(j)) snaps.append(start - offsetList.at(j));
3466                     if (end > offsetList.at(j)) snaps.append(end - offsetList.at(j));
3467                 }
3468             }
3469             // Add clip markers
3470             QList < GenTime > markers = item->snapMarkers();
3471             for (int j = 0; j < markers.size(); ++j) {
3472                 GenTime t = markers.at(j);
3473                 snaps.append(t);
3474                 if (!offsetList.isEmpty()) {
3475                     for (int k = 0; k < offsetList.size(); k++) {
3476                         if (t > offsetList.at(k)) snaps.append(t - offsetList.at(k));
3477                     }
3478                 }
3479             }
3480         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
3481             Transition *transition = static_cast <Transition*>(itemList.at(i));
3482             GenTime start = transition->startPos();
3483             GenTime end = transition->endPos();
3484             snaps.append(start);
3485             snaps.append(end);
3486             if (!offsetList.isEmpty()) {
3487                 for (int j = 0; j < offsetList.size(); j++) {
3488                     if (start > offsetList.at(j)) snaps.append(start - offsetList.at(j));
3489                     if (end > offsetList.at(j)) snaps.append(end - offsetList.at(j));
3490                 }
3491             }
3492         }
3493     }
3494
3495     // add cursor position
3496     GenTime pos = GenTime(m_cursorPos, m_document->fps());
3497     snaps.append(pos);
3498     if (!offsetList.isEmpty()) {
3499         for (int j = 0; j < offsetList.size(); j++) {
3500             snaps.append(pos - offsetList.at(j));
3501         }
3502     }
3503
3504     // add guides
3505     for (int i = 0; i < m_guides.count(); i++) {
3506         snaps.append(m_guides.at(i)->position());
3507         if (!offsetList.isEmpty()) {
3508             for (int j = 0; j < offsetList.size(); j++) {
3509                 snaps.append(m_guides.at(i)->position() - offsetList.at(j));
3510             }
3511         }
3512     }
3513
3514     qSort(snaps);
3515     m_scene->setSnapList(snaps);
3516     //for (int i = 0; i < m_snapPoints.size(); ++i)
3517     //    kDebug() << "SNAP POINT: " << m_snapPoints.at(i).frames(25);
3518 }
3519
3520 void CustomTrackView::slotSeekToPreviousSnap()
3521 {
3522     updateSnapPoints(NULL);
3523     GenTime res = m_scene->previousSnapPoint(GenTime(m_cursorPos, m_document->fps()));
3524     setCursorPos((int) res.frames(m_document->fps()));
3525     checkScrolling();
3526 }
3527
3528 void CustomTrackView::slotSeekToNextSnap()
3529 {
3530     updateSnapPoints(NULL);
3531     GenTime res = m_scene->nextSnapPoint(GenTime(m_cursorPos, m_document->fps()));
3532     setCursorPos((int) res.frames(m_document->fps()));
3533     checkScrolling();
3534 }
3535
3536 void CustomTrackView::clipStart()
3537 {
3538     ClipItem *item = getMainActiveClip();
3539     if (item != NULL) {
3540         setCursorPos((int) item->startPos().frames(m_document->fps()));
3541         checkScrolling();
3542     }
3543 }
3544
3545 void CustomTrackView::clipEnd()
3546 {
3547     ClipItem *item = getMainActiveClip();
3548     if (item != NULL) {
3549         setCursorPos((int) item->endPos().frames(m_document->fps()) - 1);
3550         checkScrolling();
3551     }
3552 }
3553
3554 void CustomTrackView::slotAddClipMarker(const QString &id, GenTime t, QString c)
3555 {
3556     QString oldcomment = m_document->clipManager()->getClipById(id)->markerComment(t);
3557     AddMarkerCommand *command = new AddMarkerCommand(this, oldcomment, c, id, t);
3558     m_commandStack->push(command);
3559 }
3560
3561 void CustomTrackView::slotDeleteClipMarker(const QString &comment, const QString &id, const GenTime &position)
3562 {
3563     AddMarkerCommand *command = new AddMarkerCommand(this, comment, QString(), id, position);
3564     m_commandStack->push(command);
3565 }
3566
3567 void CustomTrackView::slotDeleteAllClipMarkers(const QString &id)
3568 {
3569     DocClipBase *base = m_document->clipManager()->getClipById(id);
3570     QList <CommentedTime> markers = base->commentedSnapMarkers();
3571
3572     if (markers.isEmpty()) {
3573         emit displayMessage(i18n("Clip has no markers"), ErrorMessage);
3574         return;
3575     }
3576     QUndoCommand *deleteMarkers = new QUndoCommand();
3577     deleteMarkers->setText("Delete clip markers");
3578
3579     for (int i = 0; i < markers.size(); i++) {
3580         new AddMarkerCommand(this, markers.at(i).comment(), QString(), id, markers.at(i).time(), deleteMarkers);
3581     }
3582     m_commandStack->push(deleteMarkers);
3583 }
3584
3585 void CustomTrackView::addMarker(const QString &id, const GenTime &pos, const QString comment)
3586 {
3587     DocClipBase *base = m_document->clipManager()->getClipById(id);
3588     if (!comment.isEmpty()) base->addSnapMarker(pos, comment);
3589     else base->deleteSnapMarker(pos);
3590     setDocumentModified();
3591     viewport()->update();
3592 }
3593
3594 bool sortGuidesList(const Guide *g1 , const Guide *g2)
3595 {
3596     return (*g1).position() < (*g2).position();
3597 }
3598
3599 int CustomTrackView::hasGuide(int pos, int offset)
3600 {
3601     for (int i = 0; i < m_guides.count(); i++) {
3602         int guidePos = m_guides.at(i)->position().frames(m_document->fps());
3603         if (qAbs(guidePos - pos) <= offset) return guidePos;
3604         else if (guidePos > pos) return -1;
3605     }
3606     return -1;
3607 }
3608
3609 void CustomTrackView::editGuide(const GenTime oldPos, const GenTime pos, const QString &comment)
3610 {
3611     if (oldPos > GenTime() && pos > GenTime()) {
3612         // move guide
3613         for (int i = 0; i < m_guides.count(); i++) {
3614             if (m_guides.at(i)->position() == oldPos) {
3615                 Guide *item = m_guides.at(i);
3616                 item->updateGuide(pos, comment);
3617                 break;
3618             }
3619         }
3620     } else if (pos > GenTime()) addGuide(pos, comment);
3621     else {
3622         // remove guide
3623         bool found = false;
3624         for (int i = 0; i < m_guides.count(); i++) {
3625             if (m_guides.at(i)->position() == oldPos) {
3626                 delete m_guides.takeAt(i);
3627                 found = true;
3628                 break;
3629             }
3630         }
3631         if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
3632     }
3633     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
3634     m_document->syncGuides(m_guides);
3635 }
3636
3637 bool CustomTrackView::addGuide(const GenTime pos, const QString &comment)
3638 {
3639     for (int i = 0; i < m_guides.count(); i++) {
3640         if (m_guides.at(i)->position() == pos) {
3641             emit displayMessage(i18n("A guide already exists at position %1", m_document->timecode().getTimecodeFromFrames(pos.frames(m_document->fps()))), ErrorMessage);
3642             return false;
3643         }
3644     }
3645     Guide *g = new Guide(this, pos, comment, m_document->fps(), m_tracksHeight * m_document->tracksCount());
3646     scene()->addItem(g);
3647     m_guides.append(g);
3648     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
3649     m_document->syncGuides(m_guides);
3650     return true;
3651 }
3652
3653 void CustomTrackView::slotAddGuide()
3654 {
3655     CommentedTime marker(GenTime(m_cursorPos, m_document->fps()), i18n("Guide"));
3656     MarkerDialog d(NULL, marker, m_document->timecode(), i18n("Add Guide"), this);
3657     if (d.exec() != QDialog::Accepted) return;
3658     if (addGuide(d.newMarker().time(), d.newMarker().comment())) {
3659         EditGuideCommand *command = new EditGuideCommand(this, GenTime(), QString(), d.newMarker().time(), d.newMarker().comment(), false);
3660         m_commandStack->push(command);
3661     }
3662 }
3663
3664 void CustomTrackView::slotEditGuide(int guidePos)
3665 {
3666     GenTime pos;
3667     if (guidePos == -1) pos = GenTime(m_cursorPos, m_document->fps());
3668     else pos = GenTime(guidePos, m_document->fps());
3669     bool found = false;
3670     for (int i = 0; i < m_guides.count(); i++) {
3671         if (m_guides.at(i)->position() == pos) {
3672             slotEditGuide(m_guides.at(i)->info());
3673             found = true;
3674             break;
3675         }
3676     }
3677     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
3678 }
3679
3680 void CustomTrackView::slotEditGuide(CommentedTime guide)
3681 {
3682     MarkerDialog d(NULL, guide, m_document->timecode(), i18n("Edit Guide"), this);
3683     if (d.exec() == QDialog::Accepted) {
3684         EditGuideCommand *command = new EditGuideCommand(this, guide.time(), guide.comment(), d.newMarker().time(), d.newMarker().comment(), true);
3685         m_commandStack->push(command);
3686     }
3687 }
3688
3689
3690 void CustomTrackView::slotEditTimeLineGuide()
3691 {
3692     if (m_dragGuide == NULL) return;
3693     CommentedTime guide = m_dragGuide->info();
3694     MarkerDialog d(NULL, guide, m_document->timecode(), i18n("Edit Guide"), this);
3695     if (d.exec() == QDialog::Accepted) {
3696         EditGuideCommand *command = new EditGuideCommand(this, guide.time(), guide.comment(), d.newMarker().time(), d.newMarker().comment(), true);
3697         m_commandStack->push(command);
3698     }
3699 }
3700
3701 void CustomTrackView::slotDeleteGuide(int guidePos)
3702 {
3703     GenTime pos;
3704     if (guidePos == -1) pos = GenTime(m_cursorPos, m_document->fps());
3705     else pos = GenTime(guidePos, m_document->fps());
3706     bool found = false;
3707     for (int i = 0; i < m_guides.count(); i++) {
3708         if (m_guides.at(i)->position() == pos) {
3709             EditGuideCommand *command = new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true);
3710             m_commandStack->push(command);
3711             found = true;
3712             break;
3713         }
3714     }
3715     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
3716 }
3717
3718
3719 void CustomTrackView::slotDeleteTimeLineGuide()
3720 {
3721     if (m_dragGuide == NULL) return;
3722     EditGuideCommand *command = new EditGuideCommand(this, m_dragGuide->position(), m_dragGuide->label(), GenTime(), QString(), true);
3723     m_commandStack->push(command);
3724 }
3725
3726
3727 void CustomTrackView::slotDeleteAllGuides()
3728 {
3729     QUndoCommand *deleteAll = new QUndoCommand();
3730     deleteAll->setText("Delete all guides");
3731     for (int i = 0; i < m_guides.count(); i++) {
3732         new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true, deleteAll);
3733     }
3734     m_commandStack->push(deleteAll);
3735 }
3736
3737 void CustomTrackView::setTool(PROJECTTOOL tool)
3738 {
3739     m_tool = tool;
3740 }
3741
3742 void CustomTrackView::setScale(double scaleFactor, double verticalScale)
3743 {
3744     QMatrix matrix;
3745     matrix = matrix.scale(scaleFactor, verticalScale);
3746     m_scene->setScale(scaleFactor, verticalScale);
3747     m_animationTimer->stop();
3748     delete m_visualTip;
3749     m_visualTip = NULL;
3750     delete m_animation;
3751     m_animation = NULL;
3752     double verticalPos = mapToScene(QPoint(0, viewport()->height() / 2)).y();
3753     setMatrix(matrix);
3754     int diff = sceneRect().width() - m_projectDuration;
3755     if (diff * matrix.m11() < 50) {
3756         if (matrix.m11() < 0.4) setSceneRect(0, 0, (m_projectDuration + 100 / matrix.m11()), sceneRect().height());
3757         else setSceneRect(0, 0, (m_projectDuration + 300), sceneRect().height());
3758     }
3759     centerOn(QPointF(cursorPos(), verticalPos));
3760 }
3761
3762 void CustomTrackView::slotRefreshGuides()
3763 {
3764     if (KdenliveSettings::showmarkers()) {
3765         kDebug() << "// refresh GUIDES";
3766         for (int i = 0; i < m_guides.count(); i++) {
3767             m_guides.at(i)->update();
3768         }
3769     }
3770 }
3771
3772 void CustomTrackView::drawBackground(QPainter * painter, const QRectF &rect)
3773 {
3774     QRectF r = rect;
3775     r.setWidth(r.width() + 1);
3776     painter->setClipRect(r);
3777     painter->drawLine(r.left(), 0, r.right(), 0);
3778     uint max = m_document->tracksCount();
3779     KColorScheme scheme(palette().currentColorGroup(), KColorScheme::Window);
3780     QColor lockedColor = scheme.background(KColorScheme::NegativeBackground).color();
3781     QColor audioColor = palette().alternateBase().color();
3782     QColor base = scheme.background(KColorScheme::NormalBackground).color();
3783     for (uint i = 0; i < max; i++) {
3784         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(lockedColor));
3785         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(audioColor));
3786         painter->drawLine(r.left(), m_tracksHeight *(i + 1), r.right(), m_tracksHeight *(i + 1));
3787     }
3788     int lowerLimit = m_tracksHeight * m_document->tracksCount() + 1;
3789     if (height() > lowerLimit)
3790         painter->fillRect(QRectF(r.left(), lowerLimit, r.width(), height() - lowerLimit), QBrush(base));
3791 }
3792
3793 bool CustomTrackView::findString(const QString &text)
3794 {
3795     QString marker;
3796     for (int i = 0; i < m_searchPoints.size(); ++i) {
3797         marker = m_searchPoints.at(i).comment();
3798         if (marker.contains(text, Qt::CaseInsensitive)) {
3799             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
3800             int vert = verticalScrollBar()->value();
3801             int hor = cursorPos();
3802             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
3803             m_findIndex = i;
3804             return true;
3805         }
3806     }
3807     return false;
3808 }
3809
3810 bool CustomTrackView::findNextString(const QString &text)
3811 {
3812     QString marker;
3813     for (int i = m_findIndex + 1; i < m_searchPoints.size(); ++i) {
3814         marker = m_searchPoints.at(i).comment();
3815         if (marker.contains(text, Qt::CaseInsensitive)) {
3816             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
3817             int vert = verticalScrollBar()->value();
3818             int hor = cursorPos();
3819             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
3820             m_findIndex = i;
3821             return true;
3822         }
3823     }
3824     m_findIndex = -1;
3825     return false;
3826 }
3827
3828 void CustomTrackView::initSearchStrings()
3829 {
3830     m_searchPoints.clear();
3831     QList<QGraphicsItem *> itemList = items();
3832     for (int i = 0; i < itemList.count(); i++) {
3833         // parse all clip names
3834         if (itemList.at(i)->type() == AVWIDGET) {
3835             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
3836             GenTime start = item->startPos();
3837             CommentedTime t(start, item->clipName());
3838             m_searchPoints.append(t);
3839             // add all clip markers
3840             QList < CommentedTime > markers = item->commentedSnapMarkers();
3841             m_searchPoints += markers;
3842         }
3843     }
3844
3845     // add guides
3846     for (int i = 0; i < m_guides.count(); i++) {
3847         m_searchPoints.append(m_guides.at(i)->info());
3848     }
3849
3850     qSort(m_searchPoints);
3851 }
3852
3853 void CustomTrackView::clearSearchStrings()
3854 {
3855     m_searchPoints.clear();
3856     m_findIndex = 0;
3857 }
3858
3859 void CustomTrackView::copyClip()
3860 {
3861     qDeleteAll(m_copiedItems);
3862     m_copiedItems.clear();
3863     QList<QGraphicsItem *> itemList = scene()->selectedItems();
3864     if (itemList.count() == 0) {
3865         emit displayMessage(i18n("Select a clip before copying"), ErrorMessage);
3866         return;
3867     }
3868     for (int i = 0; i < itemList.count(); i++) {
3869         if (itemList.at(i)->type() == AVWIDGET) {
3870             ClipItem *dup = static_cast <ClipItem *>(itemList.at(i));
3871             m_copiedItems.append(dup->clone(dup->info()));
3872         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
3873             Transition *dup = static_cast <Transition *>(itemList.at(i));
3874             m_copiedItems.append(dup->clone());
3875         }
3876     }
3877 }
3878
3879 bool CustomTrackView::canBePastedTo(ItemInfo info, int type) const
3880 {
3881     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));
3882     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
3883     for (int i = 0; i < collisions.count(); i++) {
3884         if (collisions.at(i)->type() == type) return false;
3885     }
3886     return true;
3887 }
3888
3889 bool CustomTrackView::canBePasted(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const
3890 {
3891     for (int i = 0; i < items.count(); i++) {
3892         ItemInfo info = items.at(i)->info();
3893         info.startPos += offset;
3894         info.endPos += offset;
3895         info.track += trackOffset;
3896         if (!canBePastedTo(info, items.at(i)->type())) return false;
3897     }
3898     return true;
3899 }
3900
3901 bool CustomTrackView::canBeMoved(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const
3902 {
3903     QPainterPath movePath;
3904     movePath.moveTo(0, 0);
3905
3906     for (int i = 0; i < items.count(); i++) {
3907         ItemInfo info = items.at(i)->info();
3908         info.startPos = info.startPos + offset;
3909         info.endPos = info.endPos + offset;
3910         info.track = info.track + trackOffset;
3911         if (info.startPos < GenTime()) {
3912             // No clip should go below 0
3913             return false;
3914         }
3915         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));
3916         movePath.addRect(rect);
3917     }
3918     QList<QGraphicsItem *> collisions = scene()->items(movePath, Qt::IntersectsItemBoundingRect);
3919     for (int i = 0; i < collisions.count(); i++) {
3920         if ((collisions.at(i)->type() == AVWIDGET || collisions.at(i)->type() == TRANSITIONWIDGET) && !items.contains(static_cast <AbstractClipItem *>(collisions.at(i)))) {
3921             kDebug() << "  ////////////   CLIP COLLISION, MOVE NOT ALLOWED";
3922             return false;
3923         }
3924     }
3925     return true;
3926 }
3927
3928 void CustomTrackView::pasteClip()
3929 {
3930     if (m_copiedItems.count() == 0) {
3931         emit displayMessage(i18n("No clip copied"), ErrorMessage);
3932         return;
3933     }
3934     QPoint position;
3935     if (m_menuPosition.isNull()) {
3936         position = mapFromGlobal(QCursor::pos());
3937         if (!underMouse() || position.y() > m_tracksHeight * m_document->tracksCount()) {
3938             emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
3939             return;
3940         }
3941     } else position = m_menuPosition;
3942     GenTime pos = GenTime((int)(mapToScene(position).x()), m_document->fps());
3943     int track = (int)(position.y() / m_tracksHeight);
3944     ItemInfo first = m_copiedItems.at(0)->info();
3945
3946     GenTime offset = pos - first.startPos;
3947     int trackOffset = track - first.track;
3948
3949     if (!canBePasted(m_copiedItems, offset, trackOffset)) {
3950         emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
3951         return;
3952     }
3953     QUndoCommand *pasteClips = new QUndoCommand();
3954     pasteClips->setText("Paste clips");
3955
3956     for (int i = 0; i < m_copiedItems.count(); i++) {
3957         // parse all clip names
3958         if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == AVWIDGET) {
3959             ClipItem *clip = static_cast <ClipItem *>(m_copiedItems.at(i));
3960             ItemInfo info;
3961             info.startPos = clip->startPos() + offset;
3962             info.endPos = clip->endPos() + offset;
3963             info.cropStart = clip->cropStart();
3964             info.track = clip->track() + trackOffset;
3965             if (canBePastedTo(info, AVWIDGET)) {
3966                 new AddTimelineClipCommand(this, clip->xml(), clip->clipProducer(), info, clip->effectList(), true, false, pasteClips);
3967             } else emit displayMessage(i18n("Cannot paste clip to selected place"), ErrorMessage);
3968         } else if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == TRANSITIONWIDGET) {
3969             Transition *tr = static_cast <Transition *>(m_copiedItems.at(i));
3970             ItemInfo info;
3971             info.startPos = tr->startPos() + offset;
3972             info.endPos = tr->endPos() + offset;
3973             info.track = tr->track() + trackOffset;
3974             if (canBePastedTo(info, TRANSITIONWIDGET)) {
3975                 if (info.startPos >= info.endPos) {
3976                     emit displayMessage(i18n("Invalid transition"), ErrorMessage);
3977                 } else new AddTransitionCommand(this, info, tr->transitionEndTrack() + trackOffset, tr->toXML(), false, true, pasteClips);
3978             } else emit displayMessage(i18n("Cannot paste transition to selected place"), ErrorMessage);
3979         }
3980     }
3981     m_commandStack->push(pasteClips);
3982 }
3983
3984 void CustomTrackView::pasteClipEffects()
3985 {
3986     if (m_copiedItems.count() != 1 || m_copiedItems.at(0)->type() != AVWIDGET) {
3987         emit displayMessage(i18n("You must copy exactly one clip before pasting effects"), ErrorMessage);
3988         return;
3989     }
3990     ClipItem *clip = static_cast < ClipItem *>(m_copiedItems.at(0));
3991     EffectsList effects = clip->effectList();
3992
3993     QUndoCommand *paste = new QUndoCommand();
3994     paste->setText("Paste effects");
3995
3996     QList<QGraphicsItem *> clips = scene()->selectedItems();
3997     for (int i = 0; i < clips.count(); ++i) {
3998         if (clips.at(i)->type() == AVWIDGET) {
3999             ClipItem *item = static_cast < ClipItem *>(clips.at(i));
4000             for (int i = 0; i < clip->effectsCount(); i++) {
4001                 new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), clip->effectAt(i), true, paste);
4002             }
4003         }
4004     }
4005     m_commandStack->push(paste);
4006 }
4007
4008
4009 ClipItem *CustomTrackView::getClipUnderCursor() const
4010 {
4011     QRectF rect((double) m_cursorPos, 0.0, 1.0, (double)(m_tracksHeight * m_document->tracksCount()));
4012     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
4013     for (int i = 0; i < collisions.count(); i++) {
4014         if (collisions.at(i)->type() == AVWIDGET) {
4015             return static_cast < ClipItem *>(collisions.at(i));
4016         }
4017     }
4018     return NULL;
4019 }
4020
4021 ClipItem *CustomTrackView::getMainActiveClip() const
4022 {
4023     QList<QGraphicsItem *> clips = scene()->selectedItems();
4024     if (clips.isEmpty()) {
4025         return getClipUnderCursor();
4026     } else {
4027         ClipItem *item = NULL;
4028         for (int i = 0; i < clips.count(); ++i) {
4029             if (clips.at(i)->type() == AVWIDGET)
4030                 item = static_cast < ClipItem *>(clips.at(i));
4031             if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos) break;
4032         }
4033         if (item) return item;
4034     }
4035     return NULL;
4036 }
4037
4038 ClipItem *CustomTrackView::getActiveClipUnderCursor(bool allowOutsideCursor) const
4039 {
4040     QList<QGraphicsItem *> clips = scene()->selectedItems();
4041     if (clips.isEmpty()) {
4042         return getClipUnderCursor();
4043     } else {
4044         ClipItem *item;
4045         // remove all items in the list that are not clips
4046         for (int i = 0; i < clips.count();) {
4047             if (clips.at(i)->type() != AVWIDGET) clips.removeAt(i);
4048             else i++;
4049         }
4050         if (clips.count() == 1 && allowOutsideCursor) return static_cast < ClipItem *>(clips.at(0));
4051         for (int i = 0; i < clips.count(); ++i) {
4052             if (clips.at(i)->type() == AVWIDGET) {
4053                 item = static_cast < ClipItem *>(clips.at(i));
4054                 if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos)
4055                     return item;
4056             }
4057         }
4058     }
4059     return NULL;
4060 }
4061
4062 void CustomTrackView::setInPoint()
4063 {
4064     ClipItem *clip = getActiveClipUnderCursor(true);
4065     if (clip == NULL) {
4066         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4067         return;
4068     }
4069     ItemInfo startInfo = clip->info();
4070     ItemInfo endInfo = startInfo;
4071     endInfo.startPos = GenTime(m_cursorPos, m_document->fps());
4072     if (endInfo.startPos >= startInfo.endPos) {
4073         // Check for invalid resize
4074         emit displayMessage(i18n("Invalid action"), ErrorMessage);
4075         return;
4076     } else if (endInfo.startPos < startInfo.startPos) {
4077         int length = m_document->renderer()->mltGetSpaceLength(endInfo.startPos, m_document->tracksCount() - startInfo.track, false);
4078         if (length < (startInfo.startPos - endInfo.startPos).frames(m_document->fps())) {
4079             emit displayMessage(i18n("Invalid action"), ErrorMessage);
4080             return;
4081         }
4082     }
4083     ResizeClipCommand *command = new ResizeClipCommand(this, startInfo, endInfo, true);
4084     m_commandStack->push(command);
4085 }
4086
4087 void CustomTrackView::setOutPoint()
4088 {
4089     ClipItem *clip = getActiveClipUnderCursor(true);
4090     if (clip == NULL) {
4091         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4092         return;
4093     }
4094     ItemInfo startInfo = clip->info();
4095     ItemInfo endInfo = clip->info();
4096     endInfo.endPos = GenTime(m_cursorPos, m_document->fps());
4097     if (endInfo.endPos <= startInfo.startPos) {
4098         // Check for invalid resize
4099         emit displayMessage(i18n("Invalid action"), ErrorMessage);
4100         return;
4101     } else if (endInfo.endPos > startInfo.endPos) {
4102         int length = m_document->renderer()->mltGetSpaceLength(endInfo.endPos, m_document->tracksCount() - startInfo.track, false);
4103         if (length < (endInfo.endPos - startInfo.endPos).frames(m_document->fps())) {
4104             emit displayMessage(i18n("Invalid action"), ErrorMessage);
4105             return;
4106         }
4107     }
4108
4109
4110
4111     ResizeClipCommand *command = new ResizeClipCommand(this, startInfo, endInfo, true);
4112     m_commandStack->push(command);
4113 }
4114
4115 void CustomTrackView::slotUpdateAllThumbs()
4116 {
4117     QList<QGraphicsItem *> itemList = items();
4118     //if (itemList.isEmpty()) return;
4119     ClipItem *item;
4120     const QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
4121     for (int i = 0; i < itemList.count(); i++) {
4122         if (itemList.at(i)->type() == AVWIDGET) {
4123             item = static_cast <ClipItem *>(itemList.at(i));
4124             if (item->clipType() != COLOR && item->clipType() != AUDIO) {
4125                 // Check if we have a cached thumbnail
4126                 if (item->clipType() == IMAGE || item->clipType() == TEXT) {
4127                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
4128                     if (QFile::exists(thumb)) {
4129                         QPixmap pix(thumb);
4130                         item->slotSetStartThumb(pix);
4131                     }
4132                 } else {
4133                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
4134                     QString endThumb = startThumb;
4135                     startThumb.append(QString::number(item->cropStart().frames(m_document->fps())) + ".png");
4136                     endThumb.append(QString::number((item->cropStart() + item->cropDuration()).frames(m_document->fps()) - 1) + ".png");
4137                     if (QFile::exists(startThumb)) {
4138                         QPixmap pix(startThumb);
4139                         item->slotSetStartThumb(pix);
4140                     }
4141                     if (QFile::exists(endThumb)) {
4142                         QPixmap pix(endThumb);
4143                         item->slotSetEndThumb(pix);
4144                     }
4145                 }
4146             }
4147             item->refreshClip(false);
4148             qApp->processEvents();
4149         }
4150     }
4151     viewport()->update();
4152 }
4153
4154 void CustomTrackView::saveThumbnails()
4155 {
4156     QList<QGraphicsItem *> itemList = items();
4157     ClipItem *item;
4158     QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
4159     for (int i = 0; i < itemList.count(); i++) {
4160         if (itemList.at(i)->type() == AVWIDGET) {
4161             item = static_cast <ClipItem *>(itemList.at(i));
4162             if (item->clipType() != COLOR) {
4163                 // Check if we have a cached thumbnail
4164                 if (item->clipType() == IMAGE || item->clipType() == TEXT || item->clipType() == AUDIO) {
4165                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
4166                     if (!QFile::exists(thumb)) {
4167                         QPixmap pix(item->startThumb());
4168                         pix.save(thumb);
4169                     }
4170                 } else {
4171                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
4172                     QString endThumb = startThumb;
4173                     startThumb.append(QString::number(item->cropStart().frames(m_document->fps())) + ".png");
4174                     endThumb.append(QString::number((item->cropStart() + item->cropDuration()).frames(m_document->fps()) - 1) + ".png");
4175                     if (!QFile::exists(startThumb)) {
4176                         QPixmap pix(item->startThumb());
4177                         pix.save(startThumb);
4178                     }
4179                     if (!QFile::exists(endThumb)) {
4180                         QPixmap pix(item->endThumb());
4181                         pix.save(endThumb);
4182                     }
4183                 }
4184             }
4185         }
4186     }
4187 }
4188
4189
4190 void CustomTrackView::slotInsertTrack(int ix)
4191 {
4192     kDebug() << "// INSERTING TRK: " << ix;
4193     QDialog d(parentWidget());
4194     Ui::AddTrack_UI view;
4195     view.setupUi(&d);
4196     view.track_nb->setMaximum(m_document->tracksCount() - 1);
4197     view.track_nb->setValue(ix);
4198     d.setWindowTitle(i18n("Insert Track"));
4199
4200     if (d.exec() == QDialog::Accepted) {
4201         ix = view.track_nb->value();
4202         if (view.before_select->currentIndex() == 1) {
4203             ix++;
4204         }
4205         TrackInfo info;
4206         if (view.video_track->isChecked()) {
4207             info.type = VIDEOTRACK;
4208             info.isMute = false;
4209             info.isBlind = false;
4210             info.isLocked = false;
4211         } else {
4212             info.type = AUDIOTRACK;
4213             info.isMute = false;
4214             info.isBlind = true;
4215             info.isLocked = false;
4216         }
4217         AddTrackCommand *addTrack = new AddTrackCommand(this, ix, info, true);
4218         m_commandStack->push(addTrack);
4219         setDocumentModified();
4220     }
4221 }
4222
4223 void CustomTrackView::slotDeleteTrack(int ix)
4224 {
4225     bool ok;
4226     ix = QInputDialog::getInteger(this, i18n("Remove Track"), i18n("Track"), ix, 0, m_document->tracksCount() - 1, 1, &ok);
4227     if (ok) {
4228         TrackInfo info = m_document->trackInfoAt(m_document->tracksCount() - ix - 1);
4229         deleteTimelineTrack(ix, info);
4230         setDocumentModified();
4231         /*AddTrackCommand* command = new AddTrackCommand(this, ix, info, false);
4232         m_commandStack->push(command);*/
4233     }
4234 }
4235
4236 void CustomTrackView::slotChangeTrack(int ix)
4237 {
4238     QDialog d(parentWidget());
4239     Ui::AddTrack_UI view;
4240     view.setupUi(&d);
4241     view.label->setText(i18n("Change track"));
4242     view.before_select->setHidden(true);
4243     view.track_nb->setMaximum(m_document->tracksCount() - 1);
4244     view.track_nb->setValue(ix);
4245     d.setWindowTitle(i18n("Change Track Type"));
4246
4247     if (m_document->trackInfoAt(m_document->tracksCount() - ix - 1).type == VIDEOTRACK)
4248         view.video_track->setChecked(true);
4249     else
4250         view.audio_track->setChecked(true);
4251
4252     if (d.exec() == QDialog::Accepted) {
4253         TrackInfo info;
4254         info.isLocked = false;
4255         info.isMute = false;
4256         ix = view.track_nb->value();
4257
4258         if (view.video_track->isChecked()) {
4259             info.type = VIDEOTRACK;
4260             info.isBlind = false;
4261         } else {
4262             info.type = AUDIOTRACK;
4263             info.isBlind = true;
4264         }
4265         changeTimelineTrack(ix, info);
4266         setDocumentModified();
4267     }
4268 }
4269
4270
4271 void CustomTrackView::deleteTimelineTrack(int ix, TrackInfo trackinfo)
4272 {
4273     double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
4274     QRectF r(0, startY, sceneRect().width(), m_tracksHeight / 2 - 1);
4275     QList<QGraphicsItem *> selection = m_scene->items(r);
4276     QUndoCommand *deleteTrack = new QUndoCommand();
4277     deleteTrack->setText("Delete track");
4278
4279     // Delete all clips in selected track
4280     for (int i = 0; i < selection.count(); i++) {
4281         if (selection.at(i)->type() == AVWIDGET) {
4282             ClipItem *item =  static_cast <ClipItem *>(selection.at(i));
4283             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, true, deleteTrack);
4284             m_scene->removeItem(item);
4285             delete item;
4286             item = NULL;
4287         } else if (selection.at(i)->type() == TRANSITIONWIDGET) {
4288             Transition *item =  static_cast <Transition *>(selection.at(i));
4289             new AddTransitionCommand(this, item->info(), item->transitionEndTrack(), item->toXML(), true, false, deleteTrack);
4290             m_scene->removeItem(item);
4291             delete item;
4292             item = NULL;
4293         }
4294     }
4295
4296     selection = m_scene->items();
4297     new AddTrackCommand(this, ix, trackinfo, false, deleteTrack);
4298     m_commandStack->push(deleteTrack);
4299 }
4300
4301 void CustomTrackView::changeTimelineTrack(int ix, TrackInfo trackinfo)
4302 {
4303     TrackInfo oldinfo = m_document->trackInfoAt(m_document->tracksCount() - ix - 1);
4304     ChangeTrackCommand *changeTrack = new ChangeTrackCommand(this, ix, oldinfo, trackinfo);
4305     m_commandStack->push(changeTrack);
4306 }
4307
4308 void CustomTrackView::autoTransition()
4309 {
4310     QList<QGraphicsItem *> itemList = scene()->selectedItems();
4311     if (itemList.count() != 1 || itemList.at(0)->type() != TRANSITIONWIDGET) {
4312         emit displayMessage(i18n("You must select one transition for this action"), ErrorMessage);
4313         return;
4314     }
4315     Transition *tr = static_cast <Transition*>(itemList.at(0));
4316     tr->setAutomatic(!tr->isAutomatic());
4317     QDomElement transition = tr->toXML();
4318     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);
4319 }
4320
4321
4322 QStringList CustomTrackView::getLadspaParams(QDomElement effect) const
4323 {
4324     QStringList result;
4325     QDomNodeList params = effect.elementsByTagName("parameter");
4326     for (int i = 0; i < params.count(); i++) {
4327         QDomElement e = params.item(i).toElement();
4328         if (!e.isNull() && e.attribute("type") == "constant") {
4329             if (e.hasAttribute("factor")) {
4330                 double factor = e.attribute("factor").toDouble();
4331                 double value = e.attribute("value").toDouble();
4332                 value = value / factor;
4333                 result.append(QString::number(value));
4334             } else result.append(e.attribute("value"));
4335         }
4336     }
4337     return result;
4338 }
4339
4340 void CustomTrackView::clipNameChanged(const QString id, const QString name)
4341 {
4342     QList<QGraphicsItem *> list = scene()->items();
4343     ClipItem *clip = NULL;
4344     for (int i = 0; i < list.size(); ++i) {
4345         if (list.at(i)->type() == AVWIDGET) {
4346             clip = static_cast <ClipItem *>(list.at(i));
4347             if (clip->clipProducer() == id) {
4348                 clip->setClipName(name);
4349             }
4350         }
4351     }
4352     viewport()->update();
4353 }
4354
4355 void CustomTrackView::getClipAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum)
4356 {
4357     minimum = GenTime();
4358     maximum = GenTime();
4359     QList<QGraphicsItem *> selection;
4360     selection = m_scene->items(0, item->track() * m_tracksHeight + m_tracksHeight / 2, sceneRect().width(), 2);
4361     selection.removeAll(item);
4362     for (int i = 0; i < selection.count(); i++) {
4363         AbstractClipItem *clip = static_cast <AbstractClipItem *>(selection.at(i));
4364         if (clip && clip->type() == AVWIDGET) {
4365             if (clip->endPos() <= item->startPos() && clip->endPos() > minimum) minimum = clip->endPos();
4366             if (clip->startPos() > item->startPos() && (clip->startPos() < maximum || maximum == GenTime())) maximum = clip->startPos();
4367         }
4368     }
4369 }
4370
4371 void CustomTrackView::getTransitionAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum)
4372 {
4373     minimum = GenTime();
4374     maximum = GenTime();
4375     QList<QGraphicsItem *> selection;
4376     selection = m_scene->items(0, (item->track() + 1) * m_tracksHeight, sceneRect().width(), 2);
4377     selection.removeAll(item);
4378     for (int i = 0; i < selection.count(); i++) {
4379         AbstractClipItem *clip = static_cast <AbstractClipItem *>(selection.at(i));
4380         if (clip && clip->type() == TRANSITIONWIDGET) {
4381             if (clip->endPos() <= item->startPos() && clip->endPos() > minimum) minimum = clip->endPos();
4382             if (clip->startPos() > item->startPos() && (clip->startPos() < maximum || maximum == GenTime())) maximum = clip->startPos();
4383         }
4384     }
4385 }
4386
4387
4388 void CustomTrackView::loadGroups(const QDomNodeList groups)
4389 {
4390     for (int i = 0; i < groups.count(); i++) {
4391         QDomNodeList children = groups.at(i).childNodes();
4392         scene()->clearSelection();
4393         for (int nodeindex = 0; nodeindex < children.count(); nodeindex++) {
4394             QDomNode n = children.item(nodeindex);
4395             QDomElement elem = n.toElement();
4396             int pos = elem.attribute("position").toInt();
4397             int track = elem.attribute("track").toInt();
4398             if (elem.tagName() == "clipitem") {
4399                 ClipItem *clip = getClipItemAt(pos, track); //m_document->tracksCount() - transitiontrack);
4400                 if (clip) clip->setSelected(true);
4401             } else {
4402                 Transition *clip = getTransitionItemAt(pos, track); //m_document->tracksCount() - transitiontrack);
4403                 if (clip) clip->setSelected(true);
4404             }
4405         }
4406         groupSelectedItems(false, true);
4407     }
4408 }
4409
4410 void CustomTrackView::splitAudio()
4411 {
4412     resetSelectionGroup();
4413     QList<QGraphicsItem *> selection = scene()->selectedItems();
4414     if (selection.isEmpty()) {
4415         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4416         return;
4417     }
4418     QUndoCommand *splitCommand = new QUndoCommand();
4419     splitCommand->setText(i18n("Split audio"));
4420     for (int i = 0; i < selection.count(); i++) {
4421         if (selection.at(i)->type() == AVWIDGET) {
4422             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
4423             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
4424                 if (clip->parentItem()) {
4425                     emit displayMessage(i18n("Cannot split audio of grouped clips"), ErrorMessage);
4426                 } else {
4427                     new SplitAudioCommand(this, clip->track(), clip->startPos(), splitCommand);
4428                 }
4429             }
4430         }
4431     }
4432     m_commandStack->push(splitCommand);
4433 }
4434
4435 void CustomTrackView::doSplitAudio(const GenTime &pos, int track, bool split)
4436 {
4437     ClipItem *clip = getClipItemAt(pos, track);
4438     if (clip == NULL) {
4439         kDebug() << "// Cannot find clip to split!!!";
4440         return;
4441     }
4442     if (split) {
4443         int start = pos.frames(m_document->fps());
4444         int freetrack = m_document->tracksCount() - track - 1;
4445         for (; freetrack > 0; freetrack--) {
4446             kDebug() << "// CHK DOC TRK:" << freetrack << ", DUR:" << m_document->renderer()->mltTrackDuration(freetrack);
4447             if (m_document->trackInfoAt(freetrack - 1).type == AUDIOTRACK) {
4448                 kDebug() << "// CHK DOC TRK:" << freetrack << ", DUR:" << m_document->renderer()->mltTrackDuration(freetrack);
4449                 if (m_document->renderer()->mltTrackDuration(freetrack) < start || m_document->renderer()->mltGetSpaceLength(pos, freetrack, false) >= clip->cropDuration().frames(m_document->fps())) {
4450                     kDebug() << "FOUND SPACE ON TRK: " << freetrack;
4451                     break;
4452                 }
4453             }
4454         }
4455         kDebug() << "GOT TRK: " << track;
4456         if (freetrack == 0) {
4457             emit displayMessage(i18n("No empty space to put clip audio"), ErrorMessage);
4458         } else {
4459             ItemInfo info;
4460             info.startPos = clip->startPos();
4461             info.endPos = clip->endPos();
4462             info.cropStart = clip->cropStart();
4463             info.track = m_document->tracksCount() - freetrack;
4464             addClip(clip->xml(), clip->clipProducer(), info, clip->effectList());
4465             scene()->clearSelection();
4466             clip->setSelected(true);
4467             ClipItem *audioClip = getClipItemAt(start, info.track);
4468             if (audioClip) {
4469                 clip->setVideoOnly(true);
4470                 m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - track, start, clip->baseClip()->videoProducer());
4471                 m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - info.track, start, clip->baseClip()->audioProducer(info.track));
4472                 audioClip->setSelected(true);
4473                 audioClip->setAudioOnly(true);
4474                 groupSelectedItems(false, true);
4475             }
4476         }
4477     } else {
4478         // unsplit clip: remove audio part and change video part to normal clip
4479         if (clip->parentItem() == NULL || clip->parentItem()->type() != GROUPWIDGET) {
4480             kDebug() << "//CANNOT FIND CLP GRP";
4481             return;
4482         }
4483         AbstractGroupItem *grp = static_cast <AbstractGroupItem *>(clip->parentItem());
4484         QList<QGraphicsItem *> children = grp->childItems();
4485         if (children.count() != 2) {
4486             kDebug() << "//SOMETHING IS WRONG WITH CLP GRP";
4487             return;
4488         }
4489         for (int i = 0; i < children.count(); i++) {
4490             if (children.at(i) != clip) {
4491                 ClipItem *clp = static_cast <ClipItem *>(children.at(i));
4492                 ItemInfo info = clip->info();
4493                 deleteClip(clp->info());
4494                 clip->setVideoOnly(false);
4495                 m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - info.track, info.startPos.frames(m_document->fps()), clip->baseClip()->producer(info.track));
4496                 break;
4497             }
4498         }
4499         clip->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
4500         m_document->clipManager()->removeGroup(grp);
4501         scene()->destroyItemGroup(grp);
4502     }
4503 }
4504
4505 void CustomTrackView::setVideoOnly()
4506 {
4507     resetSelectionGroup();
4508     QList<QGraphicsItem *> selection = scene()->selectedItems();
4509     if (selection.isEmpty()) {
4510         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4511         return;
4512     }
4513     QUndoCommand *videoCommand = new QUndoCommand();
4514     videoCommand->setText(i18n("Video only"));
4515     for (int i = 0; i < selection.count(); i++) {
4516         if (selection.at(i)->type() == AVWIDGET) {
4517             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
4518             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
4519                 if (clip->parentItem()) {
4520                     emit displayMessage(i18n("Cannot change grouped clips"), ErrorMessage);
4521                 } else {
4522                     new ChangeClipTypeCommand(this, clip->track(), clip->startPos(), true, false, clip->isVideoOnly(), clip->isAudioOnly(), videoCommand);
4523                 }
4524             }
4525         }
4526     }
4527     m_commandStack->push(videoCommand);
4528 }
4529
4530 void CustomTrackView::setAudioOnly()
4531 {
4532     resetSelectionGroup();
4533     QList<QGraphicsItem *> selection = scene()->selectedItems();
4534     if (selection.isEmpty()) {
4535         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4536         return;
4537     }
4538     QUndoCommand *videoCommand = new QUndoCommand();
4539     videoCommand->setText(i18n("Audio only"));
4540     for (int i = 0; i < selection.count(); i++) {
4541         if (selection.at(i)->type() == AVWIDGET) {
4542             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
4543             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
4544                 if (clip->parentItem()) {
4545                     emit displayMessage(i18n("Cannot change grouped clips"), ErrorMessage);
4546                 } else {
4547                     new ChangeClipTypeCommand(this, clip->track(), clip->startPos(), false, true, clip->isVideoOnly(), clip->isAudioOnly(), videoCommand);
4548                 }
4549             }
4550         }
4551     }
4552     m_commandStack->push(videoCommand);
4553 }
4554
4555 void CustomTrackView::setAudioAndVideo()
4556 {
4557     resetSelectionGroup();
4558     QList<QGraphicsItem *> selection = scene()->selectedItems();
4559     if (selection.isEmpty()) {
4560         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4561         return;
4562     }
4563     QUndoCommand *videoCommand = new QUndoCommand();
4564     videoCommand->setText(i18n("Audio and Video"));
4565     for (int i = 0; i < selection.count(); i++) {
4566         if (selection.at(i)->type() == AVWIDGET) {
4567             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
4568             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
4569                 if (clip->parentItem()) {
4570                     emit displayMessage(i18n("Cannot change grouped clips"), ErrorMessage);
4571                 } else {
4572                     new ChangeClipTypeCommand(this, clip->track(), clip->startPos(), false, false, clip->isVideoOnly(), clip->isAudioOnly(), videoCommand);
4573                 }
4574             }
4575         }
4576     }
4577     m_commandStack->push(videoCommand);
4578 }
4579
4580 void CustomTrackView::doChangeClipType(const GenTime &pos, int track, bool videoOnly, bool audioOnly)
4581 {
4582     ClipItem *clip = getClipItemAt(pos, track);
4583     if (clip == NULL) {
4584         kDebug() << "// Cannot find clip to split!!!";
4585         return;
4586     }
4587     if (videoOnly) {
4588         int start = pos.frames(m_document->fps());
4589         clip->setVideoOnly(true);
4590         clip->setAudioOnly(false);
4591         m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - track, start, clip->baseClip()->videoProducer());
4592     } else if (audioOnly) {
4593         int start = pos.frames(m_document->fps());
4594         clip->setAudioOnly(true);
4595         clip->setVideoOnly(false);
4596         m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - track, start, clip->baseClip()->audioProducer(track));
4597     } else {
4598         int start = pos.frames(m_document->fps());
4599         clip->setAudioOnly(false);
4600         clip->setVideoOnly(false);
4601         m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - track, start, clip->baseClip()->producer(track));
4602     }
4603     clip->update();
4604     setDocumentModified();
4605 }
4606
4607 void CustomTrackView::updateClipTypeActions(ClipItem *clip)
4608 {
4609     if (clip == NULL || (clip->clipType() != AV && clip->clipType() != PLAYLIST)) {
4610         m_clipTypeGroup->setEnabled(false);
4611     } else {
4612         m_clipTypeGroup->setEnabled(true);
4613         QList <QAction *> actions = m_clipTypeGroup->actions();
4614         QString lookup;
4615         if (clip->isAudioOnly()) lookup = "clip_audio_only";
4616         else if (clip->isVideoOnly()) lookup = "clip_video_only";
4617         else  lookup = "clip_audio_and_video";
4618         for (int i = 0; i < actions.count(); i++) {
4619             if (actions.at(i)->data().toString() == lookup) {
4620                 actions.at(i)->setChecked(true);
4621                 break;
4622             }
4623         }
4624     }
4625 }
4626
4627 void CustomTrackView::reloadTransitionLumas()
4628 {
4629     QString lumaNames;
4630     QString lumaFiles;
4631     QDomElement lumaTransition = MainWindow::transitions.getEffectByTag("luma", "luma");
4632     QDomNodeList params = lumaTransition.elementsByTagName("parameter");
4633     for (int i = 0; i < params.count(); i++) {
4634         QDomElement e = params.item(i).toElement();
4635         if (e.attribute("tag") == "resource") {
4636             lumaNames = e.attribute("paramlistdisplay");
4637             lumaFiles = e.attribute("paramlist");
4638             break;
4639         }
4640     }
4641
4642     QList<QGraphicsItem *> itemList = items();
4643     Transition *transitionitem;
4644     QDomElement transitionXml;
4645     for (int i = 0; i < itemList.count(); i++) {
4646         if (itemList.at(i)->type() == TRANSITIONWIDGET) {
4647             transitionitem = static_cast <Transition*>(itemList.at(i));
4648             transitionXml = transitionitem->toXML();
4649             if (transitionXml.attribute("id") == "luma" && transitionXml.attribute("tag") == "luma") {
4650                 QDomNodeList params = transitionXml.elementsByTagName("parameter");
4651                 for (int i = 0; i < params.count(); i++) {
4652                     QDomElement e = params.item(i).toElement();
4653                     if (e.attribute("tag") == "resource") {
4654                         e.setAttribute("paramlistdisplay", lumaNames);
4655                         e.setAttribute("paramlist", lumaFiles);
4656                         break;
4657                     }
4658                 }
4659             }
4660             if (transitionXml.attribute("id") == "composite" && transitionXml.attribute("tag") == "composite") {
4661                 QDomNodeList params = transitionXml.elementsByTagName("parameter");
4662                 for (int i = 0; i < params.count(); i++) {
4663                     QDomElement e = params.item(i).toElement();
4664                     if (e.attribute("tag") == "luma") {
4665                         e.setAttribute("paramlistdisplay", lumaNames);
4666                         e.setAttribute("paramlist", lumaFiles);
4667                         break;
4668                     }
4669                 }
4670             }
4671         }
4672     }
4673     emit transitionItemSelected(NULL);
4674 }
4675
4676 #include "customtrackview.moc"