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             effectParams = clip->getEffectArgs(effect);
1392         }
1393         if (effectParams.paramValue("disabled") == "1") {
1394             if (m_document->renderer()->mltRemoveEffect(track, pos, effectParams.paramValue("kdenlive_ix"), false)) {
1395                 kDebug() << "//////  DISABLING EFFECT: " << ix << ", CURRENTLA: " << clip->selectedEffectIndex();
1396             } else emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
1397         } else if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - clip->track(), clip->startPos(), effectParams))
1398             emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
1399
1400         clip->setEffectAt(ix, effect);
1401         if (ix == clip->selectedEffectIndex()) {
1402             clip->setSelectedEffect(ix);
1403             if (!triggeredByUser) emit clipItemSelected(clip, ix);
1404         }
1405         if (effect.attribute("tag") == "volume" || effect.attribute("tag") == "brightness") {
1406             // A fade effect was modified, update the clip
1407             if (effect.attribute("id") == "fadein" || effect.attribute("id") == "fade_from_black") {
1408                 int pos = effectParams.paramValue("out").toInt() - effectParams.paramValue("in").toInt();
1409                 clip->setFadeIn(pos);
1410             }
1411             if (effect.attribute("id") == "fadeout" || effect.attribute("id") == "fade_to_black") {
1412                 int pos = effectParams.paramValue("out").toInt() - effectParams.paramValue("in").toInt();
1413                 clip->setFadeOut(pos);
1414             }
1415         }
1416     }
1417     setDocumentModified();
1418 }
1419
1420 void CustomTrackView::moveEffect(int track, GenTime pos, int oldPos, int newPos)
1421 {
1422     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1423     if (clip) {
1424         m_document->renderer()->mltMoveEffect(track, pos, oldPos, newPos);
1425         QDomElement act = clip->effectAt(newPos - 1).cloneNode().toElement();
1426         QDomElement before = clip->effectAt(oldPos - 1).cloneNode().toElement();
1427         clip->setEffectAt(oldPos - 1, act);
1428         clip->setEffectAt(newPos - 1, before);
1429         emit clipItemSelected(clip, newPos - 1);
1430     }
1431     setDocumentModified();
1432 }
1433
1434 void CustomTrackView::slotChangeEffectState(ClipItem *clip, int effectPos, bool disable)
1435 {
1436     QDomElement effect = clip->effectAt(effectPos);
1437     QDomElement oldEffect = effect.cloneNode().toElement();
1438     effect.setAttribute("disabled", disable);
1439     EditEffectCommand *command = new EditEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), oldEffect, effect, effectPos, true);
1440     m_commandStack->push(command);
1441     setDocumentModified();;
1442 }
1443
1444 void CustomTrackView::slotChangeEffectPosition(ClipItem *clip, int currentPos, int newPos)
1445 {
1446     MoveEffectCommand *command = new MoveEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), currentPos, newPos);
1447     m_commandStack->push(command);
1448     setDocumentModified();
1449 }
1450
1451 void CustomTrackView::slotUpdateClipEffect(ClipItem *clip, QDomElement oldeffect, QDomElement effect, int ix)
1452 {
1453     EditEffectCommand *command = new EditEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), oldeffect, effect, ix, true);
1454     m_commandStack->push(command);
1455 }
1456
1457 void CustomTrackView::cutClip(ItemInfo info, GenTime cutTime, bool cut)
1458 {
1459     if (cut) {
1460         // cut clip
1461         ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
1462         if (!item || cutTime >= item->endPos() || cutTime <= item->startPos()) {
1463             emit displayMessage(i18n("Cannot find clip to cut"), ErrorMessage);
1464             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);
1465             m_blockRefresh = false;
1466             return;
1467         }
1468         if (item->parentItem()) {
1469             // Item is part of a group, reset group
1470             resetSelectionGroup();
1471         }
1472         kDebug() << "/////////  CUTTING CLIP : (" << item->startPos().frames(25) << "-" << item->endPos().frames(25) << "), INFO: (" << info.startPos.frames(25) << "-" << info.endPos.frames(25) << ")" << ", CUT: " << cutTime.frames(25);
1473
1474         m_document->renderer()->mltCutClip(m_document->tracksCount() - info.track, cutTime);
1475         int cutPos = (int) cutTime.frames(m_document->fps());
1476         ItemInfo newPos;
1477         double speed = item->speed();
1478         newPos.startPos = cutTime;
1479         newPos.endPos = info.endPos;
1480         if (speed == 1) newPos.cropStart = item->info().cropStart + (cutTime - info.startPos);
1481         else newPos.cropStart = item->info().cropStart + (cutTime - info.startPos) * speed;
1482         newPos.track = info.track;
1483         ClipItem *dup = item->clone(newPos);
1484         // remove unwanted effects (fade in) from 2nd part of cutted clip
1485         int ix = dup->hasEffect(QString(), "fadein");
1486         if (ix != -1) {
1487             QDomElement oldeffect = item->effectAt(ix);
1488             dup->deleteEffect(oldeffect.attribute("kdenlive_ix"));
1489         }
1490         ix = dup->hasEffect(QString(), "fade_from_black");
1491         if (ix != -1) {
1492             QDomElement oldeffect = item->effectAt(ix);
1493             dup->deleteEffect(oldeffect.attribute("kdenlive_ix"));
1494         }
1495         item->resizeEnd(cutPos, false);
1496         scene()->addItem(dup);
1497         if (item->checkKeyFrames()) slotRefreshEffects(item);
1498         if (dup->checkKeyFrames()) slotRefreshEffects(dup);
1499         item->baseClip()->addReference();
1500         m_document->updateClip(item->baseClip()->getId());
1501         setDocumentModified();
1502         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);
1503         kDebug() << "//  CUTTING CLIP dONE";
1504     } else {
1505         // uncut clip
1506
1507         ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
1508         ClipItem *dup = getClipItemAt((int) cutTime.frames(m_document->fps()) + 1, info.track);
1509         if (!item || !dup || item == dup) {
1510             emit displayMessage(i18n("Cannot find clip to uncut"), ErrorMessage);
1511             m_blockRefresh = false;
1512             return;
1513         }
1514         if (m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, cutTime) == false) {
1515             emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(cutTime.frames(m_document->fps())), info.track), ErrorMessage);
1516             return;
1517         }
1518
1519         kDebug() << "// UNCUTTING CLIPS: ITEM 1 (" << item->startPos().frames(25) << "x" << item->endPos().frames(25) << ")";
1520         kDebug() << "// UNCUTTING CLIPS: ITEM 2 (" << dup->startPos().frames(25) << "x" << dup->endPos().frames(25) << ")";
1521         kDebug() << "// UNCUTTING CLIPS, INFO (" << info.startPos.frames(25) << "x" << info.endPos.frames(25) << ") , CUT: " << cutTime.frames(25);;
1522         //deleteClip(dup->info());
1523
1524
1525         if (dup->isSelected()) emit clipItemSelected(NULL);
1526         dup->baseClip()->removeReference();
1527         m_document->updateClip(dup->baseClip()->getId());
1528         scene()->removeItem(dup);
1529         delete dup;
1530
1531         ItemInfo clipinfo = item->info();
1532         clipinfo.track = m_document->tracksCount() - clipinfo.track;
1533         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, info.endPos - info.startPos);
1534         if (success) {
1535             item->resizeEnd((int) info.endPos.frames(m_document->fps()));
1536             setDocumentModified();
1537         } else
1538             emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
1539
1540     }
1541     QTimer::singleShot(3000, this, SLOT(slotEnableRefresh()));
1542 }
1543
1544 void CustomTrackView::slotEnableRefresh()
1545 {
1546     m_blockRefresh = false;
1547 }
1548
1549 void CustomTrackView::slotAddTransitionToSelectedClips(QDomElement transition)
1550 {
1551     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1552     if (itemList.count() == 1) {
1553         if (itemList.at(0)->type() == AVWIDGET) {
1554             ClipItem *item = (ClipItem *) itemList.at(0);
1555             ItemInfo info;
1556             info.track = item->track();
1557             ClipItem *transitionClip = NULL;
1558             const int transitiontrack = getPreviousVideoTrack(info.track);
1559             GenTime pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
1560             if (pos < item->startPos() + item->cropDuration() / 2) {
1561                 // add transition to clip start
1562                 info.startPos = item->startPos();
1563                 if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.startPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
1564                 if (transitionClip && transitionClip->endPos() < item->endPos()) {
1565                     info.endPos = transitionClip->endPos();
1566                 } else info.endPos = info.startPos + GenTime(65, m_document->fps());
1567                 // Check there is no other transition at that place
1568                 double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
1569                 QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
1570                 QList<QGraphicsItem *> selection = m_scene->items(r);
1571                 bool transitionAccepted = true;
1572                 for (int i = 0; i < selection.count(); i++) {
1573                     if (selection.at(i)->type() == TRANSITIONWIDGET) {
1574                         Transition *tr = static_cast <Transition *>(selection.at(i));
1575                         if (tr->startPos() - info.startPos > GenTime(5, m_document->fps())) {
1576                             if (tr->startPos() < info.endPos) info.endPos = tr->startPos();
1577                         } else transitionAccepted = false;
1578                     }
1579                 }
1580                 if (transitionAccepted) slotAddTransition(item, info, transitiontrack, transition);
1581                 else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1582
1583             } else {
1584                 // add transition to clip  end
1585                 info.endPos = item->endPos();
1586                 if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.endPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
1587                 if (transitionClip && transitionClip->startPos() > item->startPos()) {
1588                     info.startPos = transitionClip->startPos();
1589                 } else info.startPos = info.endPos - GenTime(65, m_document->fps());
1590                 if (transition.attribute("tag") == "luma") EffectsList::setParameter(transition, "reverse", "1");
1591                 else if (transition.attribute("id") == "slide") EffectsList::setParameter(transition, "invert", "1");
1592
1593                 // Check there is no other transition at that place
1594                 double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
1595                 QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
1596                 QList<QGraphicsItem *> selection = m_scene->items(r);
1597                 bool transitionAccepted = true;
1598                 for (int i = 0; i < selection.count(); i++) {
1599                     if (selection.at(i)->type() == TRANSITIONWIDGET) {
1600                         Transition *tr = static_cast <Transition *>(selection.at(i));
1601                         if (info.endPos - tr->endPos() > GenTime(5, m_document->fps())) {
1602                             if (tr->endPos() > info.startPos) info.startPos = tr->endPos();
1603                         } else transitionAccepted = false;
1604                     }
1605                 }
1606                 if (transitionAccepted) slotAddTransition(item, info, transitiontrack, transition);
1607                 else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1608             }
1609         }
1610     } else for (int i = 0; i < itemList.count(); i++) {
1611             if (itemList.at(i)->type() == AVWIDGET) {
1612                 ClipItem *item = (ClipItem *) itemList.at(i);
1613                 ItemInfo info;
1614                 info.startPos = item->startPos();
1615                 info.endPos = info.startPos + GenTime(65, m_document->fps());
1616                 info.track = item->track();
1617
1618                 // Check there is no other transition at that place
1619                 double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
1620                 QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
1621                 QList<QGraphicsItem *> selection = m_scene->items(r);
1622                 bool transitionAccepted = true;
1623                 for (int i = 0; i < selection.count(); i++) {
1624                     if (selection.at(i)->type() == TRANSITIONWIDGET) {
1625                         Transition *tr = static_cast <Transition *>(selection.at(i));
1626                         if (tr->startPos() - info.startPos > GenTime(5, m_document->fps())) {
1627                             if (tr->startPos() < info.endPos) info.endPos = tr->startPos();
1628                         } else transitionAccepted = false;
1629                     }
1630                 }
1631                 int transitiontrack = getPreviousVideoTrack(info.track);
1632                 if (transitionAccepted) slotAddTransition(item, info, transitiontrack, transition);
1633                 else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1634             }
1635         }
1636 }
1637
1638 void CustomTrackView::slotAddTransition(ClipItem* /*clip*/, ItemInfo transitionInfo, int endTrack, QDomElement transition)
1639 {
1640     if (transitionInfo.startPos >= transitionInfo.endPos) {
1641         emit displayMessage(i18n("Invalid transition"), ErrorMessage);
1642         return;
1643     }
1644     AddTransitionCommand* command = new AddTransitionCommand(this, transitionInfo, endTrack, transition, false, true);
1645     m_commandStack->push(command);
1646     setDocumentModified();
1647 }
1648
1649 void CustomTrackView::addTransition(ItemInfo transitionInfo, int endTrack, QDomElement params)
1650 {
1651     Transition *tr = new Transition(transitionInfo, endTrack, m_document->fps(), params, true);
1652     //kDebug() << "---- ADDING transition " << params.attribute("value");
1653     if (m_document->renderer()->mltAddTransition(tr->transitionTag(), endTrack, m_document->tracksCount() - transitionInfo.track, transitionInfo.startPos, transitionInfo.endPos, tr->toXML())) {
1654         scene()->addItem(tr);
1655         setDocumentModified();
1656     } else {
1657         emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1658         delete tr;
1659     }
1660 }
1661
1662 void CustomTrackView::deleteTransition(ItemInfo transitionInfo, int endTrack, QDomElement /*params*/)
1663 {
1664     Transition *item = getTransitionItemAt(transitionInfo.startPos, transitionInfo.track);
1665     if (!item) {
1666         emit displayMessage(i18n("Select clip to delete"), ErrorMessage);
1667         return;
1668     }
1669     m_document->renderer()->mltDeleteTransition(item->transitionTag(), endTrack, m_document->tracksCount() - transitionInfo.track, transitionInfo.startPos, transitionInfo.endPos, item->toXML());
1670     if (m_dragItem == item) m_dragItem = NULL;
1671     delete item;
1672     emit transitionItemSelected(NULL);
1673     setDocumentModified();
1674 }
1675
1676 void CustomTrackView::slotTransitionUpdated(Transition *tr, QDomElement old)
1677 {
1678     kDebug() << "TRANS UPDATE, TRACKS: " << old.attribute("transition_btrack") << ", NEW: " << tr->toXML().attribute("transition_btrack");
1679     EditTransitionCommand *command = new EditTransitionCommand(this, tr->track(), tr->startPos(), old, tr->toXML(), false);
1680     m_commandStack->push(command);
1681     setDocumentModified();
1682 }
1683
1684 void CustomTrackView::updateTransition(int track, GenTime pos, QDomElement oldTransition, QDomElement transition, bool updateTransitionWidget)
1685 {
1686     Transition *item = getTransitionItemAt(pos, track);
1687     if (!item) {
1688         kWarning() << "Unable to find transition at pos :" << pos.frames(m_document->fps()) << ", ON track: " << track;
1689         return;
1690     }
1691     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);
1692     //kDebug() << "ORIGINAL TRACK: "<< oldTransition.attribute("transition_btrack") << ", NEW TRACK: "<<transition.attribute("transition_btrack");
1693     item->setTransitionParameters(transition);
1694     if (updateTransitionWidget) {
1695         ItemInfo info = item->info();
1696         QPoint p;
1697         ClipItem *transitionClip = getClipItemAt(info.startPos, info.track);
1698         if (transitionClip && transitionClip->baseClip()) {
1699             QString size = transitionClip->baseClip()->getProperty("frame_size");
1700             p.setX(size.section('x', 0, 0).toInt());
1701             p.setY(size.section('x', 1, 1).toInt());
1702         }
1703         emit transitionItemSelected(item, getPreviousVideoTrack(info.track), p, true);
1704     }
1705     setDocumentModified();
1706 }
1707
1708 void CustomTrackView::dragMoveEvent(QDragMoveEvent * event)
1709 {
1710     event->setDropAction(Qt::IgnoreAction);
1711     const QPointF pos = mapToScene(event->pos());
1712     if (m_selectionGroup && m_clipDrag) {
1713         m_selectionGroup->setPos(pos.x(), pos.y());
1714         emit mousePosition((int)(m_selectionGroup->scenePos().x() + 0.5));
1715         event->setDropAction(Qt::MoveAction);
1716         event->acceptProposedAction();
1717     } else {
1718         QGraphicsView::dragMoveEvent(event);
1719     }
1720 }
1721
1722 void CustomTrackView::dragLeaveEvent(QDragLeaveEvent * event)
1723 {
1724     if (m_selectionGroup && m_clipDrag) {
1725         m_thumbsTimer.stop();
1726         m_waitingThumbs.clear();
1727         QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1728         qDeleteAll(items);
1729         scene()->destroyItemGroup(m_selectionGroup);
1730         m_selectionGroup = NULL;
1731     } else QGraphicsView::dragLeaveEvent(event);
1732 }
1733
1734 void CustomTrackView::dropEvent(QDropEvent * event)
1735 {
1736     if (m_selectionGroup && m_clipDrag) {
1737         QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1738         resetSelectionGroup();
1739         m_scene->clearSelection();
1740         bool hasVideoClip = false;
1741         QUndoCommand *addCommand = new QUndoCommand();
1742         addCommand->setText(i18n("Add timeline clip"));
1743
1744         for (int i = 0; i < items.count(); i++) {
1745             ClipItem *item = static_cast <ClipItem *>(items.at(i));
1746             if (!hasVideoClip && (item->clipType() == AV || item->clipType() == VIDEO)) hasVideoClip = true;
1747             if (items.count() == 1) {
1748                 updateClipTypeActions(item);
1749             } else {
1750                 updateClipTypeActions(NULL);
1751             }
1752
1753             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, false, addCommand);
1754             item->baseClip()->addReference();
1755             m_document->updateClip(item->baseClip()->getId());
1756             ItemInfo info = item->info();
1757
1758             int tracknumber = m_document->tracksCount() - info.track - 1;
1759             bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
1760             if (isLocked) item->setItemLocked(true);
1761
1762             if (item->baseClip()->isTransparent() && getTransitionItemAtStart(info.startPos, info.track) == NULL) {
1763                 // add transparency transition
1764                 new AddTransitionCommand(this, info, getPreviousVideoTrack(info.track), MainWindow::transitions.getEffectByTag("composite", "composite"), false, true, addCommand);
1765             }
1766             info.track = m_document->tracksCount() - item->track();
1767             m_document->renderer()->mltInsertClip(info, item->xml(), item->baseClip()->producer(item->track()));
1768             item->setSelected(true);
1769         }
1770         m_commandStack->push(addCommand);
1771         setDocumentModified();
1772         m_changeSpeedAction->setEnabled(hasVideoClip);
1773         m_pasteEffectsAction->setEnabled(m_copiedItems.count() == 1);
1774         if (items.count() > 1) groupSelectedItems(true);
1775     } else QGraphicsView::dropEvent(event);
1776     setFocus();
1777 }
1778
1779
1780 QStringList CustomTrackView::mimeTypes() const
1781 {
1782     QStringList qstrList;
1783     // list of accepted mime types for drop
1784     qstrList.append("text/plain");
1785     qstrList.append("kdenlive/producerslist");
1786     qstrList.append("kdenlive/clip");
1787     return qstrList;
1788 }
1789
1790 Qt::DropActions CustomTrackView::supportedDropActions() const
1791 {
1792     // returns what actions are supported when dropping
1793     return Qt::MoveAction;
1794 }
1795
1796 void CustomTrackView::setDuration(int duration)
1797 {
1798     int diff = qAbs(duration - sceneRect().width());
1799     if (diff * matrix().m11() > -50) {
1800         if (matrix().m11() < 0.4) setSceneRect(0, 0, (duration + 100 / matrix().m11()), sceneRect().height());
1801         else setSceneRect(0, 0, (duration + 300), sceneRect().height());
1802     }
1803     m_projectDuration = duration;
1804 }
1805
1806 int CustomTrackView::duration() const
1807 {
1808     return m_projectDuration;
1809 }
1810
1811 void CustomTrackView::addTrack(TrackInfo type, int ix)
1812 {
1813     if (ix == -1 || ix == m_document->tracksCount()) {
1814         m_document->insertTrack(ix, type);
1815         m_document->renderer()->mltInsertTrack(1, type.type == VIDEOTRACK);
1816     } else {
1817         m_document->insertTrack(m_document->tracksCount() - ix, type);
1818         // insert track in MLT playlist
1819         m_document->renderer()->mltInsertTrack(m_document->tracksCount() - ix, type.type == VIDEOTRACK);
1820
1821         double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
1822         QRectF r(0, startY, sceneRect().width(), sceneRect().height() - startY);
1823         QList<QGraphicsItem *> selection = m_scene->items(r);
1824         resetSelectionGroup();
1825
1826         m_selectionGroup = new AbstractGroupItem(m_document->fps());
1827         scene()->addItem(m_selectionGroup);
1828         for (int i = 0; i < selection.count(); i++) {
1829             if ((!selection.at(i)->parentItem()) && (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET || selection.at(i)->type() == GROUPWIDGET)) {
1830                 m_selectionGroup->addToGroup(selection.at(i));
1831                 selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
1832             }
1833         }
1834         // Move graphic items
1835         m_selectionGroup->translate(0, m_tracksHeight);
1836
1837         // adjust track number
1838         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
1839         for (int i = 0; i < children.count(); i++) {
1840             if (children.at(i)->type() == GROUPWIDGET) {
1841                 AbstractGroupItem *grp = static_cast<AbstractGroupItem*>(children.at(i));
1842                 children << grp->childItems();
1843                 continue;
1844             }
1845             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
1846             item->updateItem();
1847             ItemInfo clipinfo = item->info();
1848             if (item->type() == AVWIDGET) {
1849                 ClipItem *clip = static_cast <ClipItem *>(item);
1850                 // We add a move clip command so that we get the correct producer for new track number
1851                 if (clip->clipType() == AV || clip->clipType() == AUDIO) {
1852                     Mlt::Producer *prod;
1853                     if (clip->isAudioOnly()) prod = clip->baseClip()->audioProducer(clipinfo.track);
1854                     else if (clip->isVideoOnly()) prod = clip->baseClip()->videoProducer();
1855                     else prod = clip->baseClip()->producer(clipinfo.track);
1856                     m_document->renderer()->mltUpdateClipProducer((int)(m_document->tracksCount() - clipinfo.track), clipinfo.startPos.frames(m_document->fps()), prod);
1857                     kDebug() << "// UPDATING CLIP TO TRACK PROD: " << clipinfo.track;
1858                 }
1859             } else if (item->type() == TRANSITIONWIDGET) {
1860                 Transition *tr = static_cast <Transition *>(item);
1861                 int track = tr->transitionEndTrack();
1862                 if (track >= ix) {
1863                     tr->updateTransitionEndTrack(getPreviousVideoTrack(clipinfo.track));
1864                 }
1865             }
1866         }
1867         resetSelectionGroup(false);
1868     }
1869
1870     int maxHeight = m_tracksHeight * m_document->tracksCount();
1871     for (int i = 0; i < m_guides.count(); i++) {
1872         QLineF l = m_guides.at(i)->line();
1873         l.setP2(QPointF(l.x2(), maxHeight));
1874         m_guides.at(i)->setLine(l);
1875     }
1876     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), maxHeight);
1877     setSceneRect(0, 0, sceneRect().width(), maxHeight);
1878     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
1879     viewport()->update();
1880     //setFixedHeight(50 * m_tracksCount);
1881 }
1882
1883 void CustomTrackView::removeTrack(int ix)
1884 {
1885     // Delete track in MLT playlist
1886     m_document->renderer()->mltDeleteTrack(m_document->tracksCount() - ix);
1887     m_document->deleteTrack(m_document->tracksCount() - ix - 1);
1888
1889     double startY = ix * (m_tracksHeight + 1) + m_tracksHeight / 2;
1890     QRectF r(0, startY, sceneRect().width(), sceneRect().height() - startY);
1891     QList<QGraphicsItem *> selection = m_scene->items(r);
1892
1893     resetSelectionGroup();
1894
1895     m_selectionGroup = new AbstractGroupItem(m_document->fps());
1896     scene()->addItem(m_selectionGroup);
1897     for (int i = 0; i < selection.count(); i++) {
1898         if ((!selection.at(i)->parentItem()) && (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET || selection.at(i)->type() == GROUPWIDGET)) {
1899             m_selectionGroup->addToGroup(selection.at(i));
1900             selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
1901         }
1902     }
1903     // Move graphic items
1904     qreal ydiff = 0 - (int) m_tracksHeight;
1905     m_selectionGroup->translate(0, ydiff);
1906
1907     // adjust track number
1908     QList<QGraphicsItem *> children = m_selectionGroup->childItems();
1909     //kDebug() << "// FOUND CLIPS TO MOVE: " << children.count();
1910     for (int i = 0; i < children.count(); i++) {
1911         if (children.at(i)->type() == GROUPWIDGET) {
1912             AbstractGroupItem *grp = static_cast<AbstractGroupItem*>(children.at(i));
1913             children << grp->childItems();
1914             continue;
1915         }
1916         if (children.at(i)->type() == AVWIDGET) {
1917             ClipItem *clip = static_cast <ClipItem *>(children.at(i));
1918             clip->updateItem();
1919             ItemInfo clipinfo = clip->info();
1920             // We add a move clip command so that we get the correct producer for new track number
1921             if (clip->clipType() == AV || clip->clipType() == AUDIO) {
1922                 Mlt::Producer *prod;
1923                 if (clip->isAudioOnly()) prod = clip->baseClip()->audioProducer(clipinfo.track);
1924                 else if (clip->isVideoOnly()) prod = clip->baseClip()->videoProducer();
1925                 else prod = clip->baseClip()->producer(clipinfo.track);
1926                 m_document->renderer()->mltUpdateClipProducer((int)(m_document->tracksCount() - clipinfo.track), clipinfo.startPos.frames(m_document->fps()), prod);
1927             }
1928         } else if (children.at(i)->type() == TRANSITIONWIDGET) {
1929             Transition *tr = static_cast <Transition *>(children.at(i));
1930             tr->updateItem();
1931             int track = tr->transitionEndTrack();
1932             if (track >= ix) {
1933                 ItemInfo clipinfo = tr->info();
1934                 tr->updateTransitionEndTrack(getPreviousVideoTrack(clipinfo.track));
1935             }
1936         }
1937     }
1938     resetSelectionGroup(false);
1939
1940     int maxHeight = m_tracksHeight * m_document->tracksCount();
1941     for (int i = 0; i < m_guides.count(); i++) {
1942         QLineF l = m_guides.at(i)->line();
1943         l.setP2(QPointF(l.x2(), maxHeight));
1944         m_guides.at(i)->setLine(l);
1945     }
1946     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), maxHeight);
1947     setSceneRect(0, 0, sceneRect().width(), maxHeight);
1948     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
1949     viewport()->update();
1950 }
1951
1952 void CustomTrackView::changeTrack(int ix, TrackInfo type)
1953 {
1954     int tracknumber = m_document->tracksCount() - ix;
1955     m_document->setTrackType(tracknumber - 1, type);
1956     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
1957     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
1958     viewport()->update();
1959 }
1960
1961
1962 void CustomTrackView::slotSwitchTrackAudio(int ix)
1963 {
1964     /*for (int i = 0; i < m_document->tracksCount(); i++)
1965         kDebug() << "TRK " << i << " STATE: " << m_document->trackInfoAt(i).isMute << m_document->trackInfoAt(i).isBlind;*/
1966     int tracknumber = m_document->tracksCount() - ix - 1;
1967     m_document->switchTrackAudio(tracknumber, !m_document->trackInfoAt(tracknumber).isMute);
1968     kDebug() << "NEXT TRK STATE: " << m_document->trackInfoAt(tracknumber).isMute << m_document->trackInfoAt(tracknumber).isBlind;
1969     m_document->renderer()->mltChangeTrackState(tracknumber + 1, m_document->trackInfoAt(tracknumber).isMute, m_document->trackInfoAt(tracknumber).isBlind);
1970     setDocumentModified();
1971 }
1972
1973 void CustomTrackView::slotSwitchTrackLock(int ix)
1974 {
1975     int tracknumber = m_document->tracksCount() - ix - 1;
1976     LockTrackCommand *command = new LockTrackCommand(this, ix, !m_document->trackInfoAt(tracknumber).isLocked);
1977     m_commandStack->push(command);
1978 }
1979
1980
1981 void CustomTrackView::lockTrack(int ix, bool lock)
1982 {
1983     int tracknumber = m_document->tracksCount() - ix - 1;
1984     m_document->switchTrackLock(tracknumber, lock);
1985     emit doTrackLock(ix, lock);
1986     QList<QGraphicsItem *> selection = m_scene->items(0, ix * m_tracksHeight + m_tracksHeight / 2, sceneRect().width(), m_tracksHeight / 2 - 2);
1987
1988     for (int i = 0; i < selection.count(); i++) {
1989         if (selection.at(i)->type() != AVWIDGET && selection.at(i)->type() != TRANSITIONWIDGET) continue;
1990         if (selection.at(i)->isSelected()) {
1991             if (selection.at(i)->type() == AVWIDGET) emit clipItemSelected(NULL);
1992             else emit transitionItemSelected(NULL);
1993         }
1994         static_cast <AbstractClipItem *>(selection.at(i))->setItemLocked(lock);
1995     }
1996     kDebug() << "NEXT TRK STATE: " << m_document->trackInfoAt(tracknumber).isLocked;
1997     viewport()->update();
1998     setDocumentModified();
1999 }
2000
2001 void CustomTrackView::slotSwitchTrackVideo(int ix)
2002 {
2003     int tracknumber = m_document->tracksCount() - ix;
2004     m_document->switchTrackVideo(tracknumber - 1, !m_document->trackInfoAt(tracknumber - 1).isBlind);
2005     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
2006     setDocumentModified();
2007 }
2008
2009 void CustomTrackView::slotRemoveSpace()
2010 {
2011     GenTime pos;
2012     int track = 0;
2013     if (m_menuPosition.isNull()) {
2014         pos = GenTime(cursorPos(), m_document->fps());
2015         bool ok;
2016         track = QInputDialog::getInteger(this, i18n("Remove Space"), i18n("Track"), 0, 0, m_document->tracksCount() - 1, 1, &ok);
2017         if (!ok) return;
2018     } else {
2019         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
2020         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight);
2021     }
2022     ClipItem *item = getClipItemAt(pos, track);
2023     if (item) {
2024         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);
2025         return;
2026     }
2027     int length = m_document->renderer()->mltGetSpaceLength(pos, m_document->tracksCount() - track, true);
2028     //kDebug() << "// GOT LENGT; " << length;
2029     if (length <= 0) {
2030         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);
2031         return;
2032     }
2033
2034     QRectF r(pos.frames(m_document->fps()), track * m_tracksHeight + m_tracksHeight / 2, sceneRect().width() - pos.frames(m_document->fps()), m_tracksHeight / 2 - 1);
2035     QList<QGraphicsItem *> items = m_scene->items(r);
2036
2037     QList<ItemInfo> clipsToMove;
2038     QList<ItemInfo> transitionsToMove;
2039
2040     for (int i = 0; i < items.count(); i++) {
2041         if (items.at(i)->type() == AVWIDGET || items.at(i)->type() == TRANSITIONWIDGET) {
2042             AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2043             ItemInfo info = item->info();
2044             if (item->type() == AVWIDGET) {
2045                 clipsToMove.append(info);
2046             } else if (item->type() == TRANSITIONWIDGET) {
2047                 transitionsToMove.append(info);
2048             }
2049         }
2050     }
2051
2052     InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, GenTime(-length, m_document->fps()), true);
2053     m_commandStack->push(command);
2054 }
2055
2056 void CustomTrackView::slotInsertSpace()
2057 {
2058     GenTime pos;
2059     int track = 0;
2060     if (m_menuPosition.isNull()) {
2061         pos = GenTime(cursorPos(), m_document->fps());
2062     } else {
2063         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
2064         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight) + 1;
2065     }
2066     SpacerDialog d(GenTime(65, m_document->fps()), m_document->timecode(), track, m_document->tracksCount(), this);
2067     if (d.exec() != QDialog::Accepted) return;
2068     GenTime spaceDuration = d.selectedDuration();
2069     track = d.selectedTrack();
2070     ClipItem *item = getClipItemAt(pos, track);
2071     if (item) pos = item->startPos();
2072
2073     int minh = 0;
2074     int maxh = sceneRect().height();
2075     if (track != -1) {
2076         minh = track * m_tracksHeight + m_tracksHeight / 2;
2077         maxh = m_tracksHeight / 2 - 1;
2078     }
2079
2080     QRectF r(pos.frames(m_document->fps()), minh, sceneRect().width() - pos.frames(m_document->fps()), maxh);
2081     QList<QGraphicsItem *> items = m_scene->items(r);
2082
2083     QList<ItemInfo> clipsToMove;
2084     QList<ItemInfo> transitionsToMove;
2085
2086     for (int i = 0; i < items.count(); i++) {
2087         if (items.at(i)->type() == AVWIDGET || items.at(i)->type() == TRANSITIONWIDGET) {
2088             AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2089             ItemInfo info = item->info();
2090             if (item->type() == AVWIDGET) {
2091                 clipsToMove.append(info);
2092             } else if (item->type() == TRANSITIONWIDGET) {
2093                 transitionsToMove.append(info);
2094             }
2095         }
2096     }
2097
2098     InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, spaceDuration, true);
2099     m_commandStack->push(command);
2100 }
2101
2102 void CustomTrackView::insertSpace(QList<ItemInfo> clipsToMove, QList<ItemInfo> transToMove, int track, const GenTime duration, const GenTime offset)
2103 {
2104     int diff = duration.frames(m_document->fps());
2105     resetSelectionGroup();
2106     m_selectionGroup = new AbstractGroupItem(m_document->fps());
2107     scene()->addItem(m_selectionGroup);
2108     ClipItem *clip;
2109     Transition *transition;
2110
2111     // Create lists with start pos for each track
2112     QMap <int, int> trackClipStartList;
2113     QMap <int, int> trackTransitionStartList;
2114
2115     for (int i = 1; i < m_document->tracksCount() + 1; i++) {
2116         trackClipStartList[i] = -1;
2117         trackTransitionStartList[i] = -1;
2118     }
2119
2120     if (!clipsToMove.isEmpty()) for (int i = 0; i < clipsToMove.count(); i++) {
2121             clip = getClipItemAtStart(clipsToMove.at(i).startPos + offset, clipsToMove.at(i).track);
2122             if (clip) {
2123                 if (clip->parentItem()) {
2124                     m_selectionGroup->addToGroup(clip->parentItem());
2125                     clip->parentItem()->setFlags(QGraphicsItem::ItemIsSelectable);
2126                 } else {
2127                     m_selectionGroup->addToGroup(clip);
2128                     clip->setFlags(QGraphicsItem::ItemIsSelectable);
2129                 }
2130                 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))
2131                     trackClipStartList[m_document->tracksCount() - clipsToMove.at(i).track] = clipsToMove.at(i).startPos.frames(m_document->fps());
2132             } 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);
2133         }
2134     if (!transToMove.isEmpty()) for (int i = 0; i < transToMove.count(); i++) {
2135             transition = getTransitionItemAtStart(transToMove.at(i).startPos + offset, transToMove.at(i).track);
2136             if (transition) {
2137                 if (transition->parentItem()) m_selectionGroup->addToGroup(transition->parentItem());
2138                 m_selectionGroup->addToGroup(transition);
2139                 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))
2140                     trackTransitionStartList[m_document->tracksCount() - transToMove.at(i).track] = transToMove.at(i).startPos.frames(m_document->fps());
2141                 transition->setFlags(QGraphicsItem::ItemIsSelectable);
2142             } 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);
2143         }
2144     m_selectionGroup->translate(diff, 0);
2145
2146     // update items coordinates
2147     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2148     for (int i = 0; i < itemList.count(); i++) {
2149         if (itemList.at(i)->type() == AVWIDGET || itemList.at(i)->type() == TRANSITIONWIDGET) {
2150             static_cast < AbstractClipItem *>(itemList.at(i))->updateItem();
2151         } else if (itemList.at(i)->type() == GROUPWIDGET) {
2152             QList<QGraphicsItem *> children = itemList.at(i)->childItems();
2153             for (int j = 0; j < children.count(); j++) {
2154                 static_cast < AbstractClipItem *>(children.at(j))->updateItem();
2155             }
2156         }
2157     }
2158     resetSelectionGroup(false);
2159     if (track != -1) track = m_document->tracksCount() - track;
2160     m_document->renderer()->mltInsertSpace(trackClipStartList, trackTransitionStartList, track, duration, offset);
2161 }
2162
2163 void CustomTrackView::deleteClip(const QString &clipId)
2164 {
2165     resetSelectionGroup();
2166     QList<QGraphicsItem *> itemList = items();
2167     QUndoCommand *deleteCommand = new QUndoCommand();
2168     deleteCommand->setText(i18n("Delete timeline clips"));
2169     int count = 0;
2170     for (int i = 0; i < itemList.count(); i++) {
2171         if (itemList.at(i)->type() == AVWIDGET) {
2172             ClipItem *item = (ClipItem *)itemList.at(i);
2173             if (item->clipProducer() == clipId) {
2174                 count++;
2175                 if (item->parentItem()) {
2176                     // Clip is in a group, destroy the group
2177                     new GroupClipsCommand(this, QList<ItemInfo>() << item->info(), QList<ItemInfo>(), false, deleteCommand);
2178                 }
2179                 new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true, deleteCommand);
2180             }
2181         }
2182     }
2183     if (count == 0) delete deleteCommand;
2184     else m_commandStack->push(deleteCommand);
2185 }
2186
2187 void CustomTrackView::setCursorPos(int pos, bool seek)
2188 {
2189     if (pos == m_cursorPos) return;
2190     emit cursorMoved((int)(m_cursorPos), (int)(pos));
2191     m_cursorPos = pos;
2192     if (seek) m_document->renderer()->seek(GenTime(m_cursorPos, m_document->fps()));
2193     else if (m_autoScroll) checkScrolling();
2194     m_cursorLine->setPos(m_cursorPos, 0);
2195 }
2196
2197 void CustomTrackView::updateCursorPos()
2198 {
2199     m_cursorLine->setPos(m_cursorPos, 0);
2200 }
2201
2202 int CustomTrackView::cursorPos()
2203 {
2204     return (int)(m_cursorPos);
2205 }
2206
2207 void CustomTrackView::moveCursorPos(int delta)
2208 {
2209     if (m_cursorPos + delta < 0) delta = 0 - m_cursorPos;
2210     emit cursorMoved((int)(m_cursorPos), (int)((m_cursorPos + delta)));
2211     m_cursorPos += delta;
2212     m_cursorLine->setPos(m_cursorPos, 0);
2213     m_document->renderer()->seek(GenTime(m_cursorPos, m_document->fps()));
2214 }
2215
2216 void CustomTrackView::initCursorPos(int pos)
2217 {
2218     emit cursorMoved((int)(m_cursorPos), (int)(pos));
2219     m_cursorPos = pos;
2220     m_cursorLine->setPos(pos, 0);
2221     checkScrolling();
2222 }
2223
2224 void CustomTrackView::checkScrolling()
2225 {
2226     ensureVisible(m_cursorPos, verticalScrollBar()->value() + 10, 2, 2, 50, 0);
2227 }
2228
2229 void CustomTrackView::mouseReleaseEvent(QMouseEvent * event)
2230 {
2231     if (m_moveOpMode == SEEK) m_moveOpMode = NONE;
2232     QGraphicsView::mouseReleaseEvent(event);
2233     if (m_scrollTimer.isActive()) m_scrollTimer.stop();
2234     if (event->button() == Qt::MidButton) {
2235         return;
2236     }
2237     setDragMode(QGraphicsView::NoDrag);
2238     if (m_operationMode == MOVEGUIDE) {
2239         setCursor(Qt::ArrowCursor);
2240         m_operationMode = NONE;
2241         m_dragGuide->setFlag(QGraphicsItem::ItemIsMovable, false);
2242         GenTime newPos = GenTime(m_dragGuide->pos().x(), m_document->fps());
2243         if (newPos != m_dragGuide->position()) {
2244             EditGuideCommand *command = new EditGuideCommand(this, m_dragGuide->position(), m_dragGuide->label(), newPos, m_dragGuide->label(), false);
2245             m_commandStack->push(command);
2246             m_dragGuide->updateGuide(GenTime(m_dragGuide->pos().x(), m_document->fps()));
2247             m_document->syncGuides(m_guides);
2248         }
2249         m_dragGuide = NULL;
2250         m_dragItem = NULL;
2251         return;
2252     } else if (m_operationMode == SPACER && m_selectionGroup) {
2253         int track;
2254         if (event->modifiers() != Qt::ControlModifier) {
2255             // We are moving all tracks
2256             track = -1;
2257         } else track = (int)(mapToScene(m_clickEvent).y() / m_tracksHeight);
2258         GenTime timeOffset = GenTime(m_selectionGroup->scenePos().x(), m_document->fps()) - m_selectionGroupInfo.startPos;
2259         if (timeOffset != GenTime()) {
2260             QList<QGraphicsItem *> items = m_selectionGroup->childItems();
2261
2262             QList<ItemInfo> clipsToMove;
2263             QList<ItemInfo> transitionsToMove;
2264
2265             // Create lists with start pos for each track
2266             QMap <int, int> trackClipStartList;
2267             QMap <int, int> trackTransitionStartList;
2268
2269             for (int i = 1; i < m_document->tracksCount() + 1; i++) {
2270                 trackClipStartList[i] = -1;
2271                 trackTransitionStartList[i] = -1;
2272             }
2273
2274             int max = items.count();
2275             for (int i = 0; i < max; i++) {
2276                 if (items.at(i)->type() == GROUPWIDGET)
2277                     items += static_cast <QGraphicsItemGroup *>(items.at(i))->childItems();
2278             }
2279
2280             for (int i = 0; i < items.count(); i++) {
2281                 if (items.at(i)->type() == AVWIDGET) {
2282                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2283                     ItemInfo info = item->info();
2284                     clipsToMove.append(info);
2285                     item->updateItem();
2286                     if (trackClipStartList.value(m_document->tracksCount() - info.track) == -1 || info.startPos.frames(m_document->fps()) < trackClipStartList.value(m_document->tracksCount() - info.track))
2287                         trackClipStartList[m_document->tracksCount() - info.track] = info.startPos.frames(m_document->fps());
2288                 } else if (items.at(i)->type() == TRANSITIONWIDGET) {
2289                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2290                     ItemInfo info = item->info();
2291                     transitionsToMove.append(info);
2292                     item->updateItem();
2293                     if (trackTransitionStartList.value(m_document->tracksCount() - info.track) == -1 || info.startPos.frames(m_document->fps()) < trackTransitionStartList.value(m_document->tracksCount() - info.track))
2294                         trackTransitionStartList[m_document->tracksCount() - info.track] = info.startPos.frames(m_document->fps());
2295                 }
2296             }
2297
2298             InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, timeOffset, false);
2299             m_commandStack->push(command);
2300             if (track != -1) track = m_document->tracksCount() - track;
2301             kDebug() << "SPACER TRACK:" << track;
2302             m_document->renderer()->mltInsertSpace(trackClipStartList, trackTransitionStartList, track, timeOffset, GenTime());
2303         }
2304         resetSelectionGroup(false);
2305         m_operationMode = NONE;
2306     } else if (m_operationMode == RUBBERSELECTION) {
2307         //kDebug() << "// END RUBBER SELECT";
2308         resetSelectionGroup();
2309         groupSelectedItems();
2310         m_operationMode = NONE;
2311     }
2312
2313     if (m_dragItem == NULL && m_selectionGroup == NULL) {
2314         emit transitionItemSelected(NULL);
2315         return;
2316     }
2317     ItemInfo info;
2318     if (m_dragItem) info = m_dragItem->info();
2319
2320     if (m_operationMode == MOVE) {
2321         setCursor(Qt::OpenHandCursor);
2322
2323         if (m_dragItem->parentItem() == 0) {
2324             // we are moving one clip, easy
2325             if (m_dragItem->type() == AVWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
2326                 ClipItem *item = static_cast <ClipItem *>(m_dragItem);
2327                 Mlt::Producer *prod;
2328                 if (item->isAudioOnly()) prod = item->baseClip()->audioProducer(m_dragItemInfo.track);
2329                 else if (item->isVideoOnly()) prod = item->baseClip()->videoProducer();
2330                 else prod = item->baseClip()->producer(m_dragItemInfo.track);
2331                 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);
2332                 if (success) {
2333                     kDebug() << "// get trans info";
2334                     int tracknumber = m_document->tracksCount() - item->track() - 1;
2335                     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2336                     if (isLocked) item->setItemLocked(true);
2337
2338                     QUndoCommand *moveCommand = new QUndoCommand();
2339                     moveCommand->setText(i18n("Move clip"));
2340                     new MoveClipCommand(this, m_dragItemInfo, info, false, moveCommand);
2341                     // Also move automatic transitions (on lower track)
2342                     Transition *tr = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track);
2343                     kDebug() << "// get trans info2";
2344                     if (tr && tr->isAutomatic()) {
2345                         ItemInfo trInfo = tr->info();
2346                         ItemInfo newTrInfo = trInfo;
2347                         newTrInfo.track = info.track;
2348                         newTrInfo.startPos = m_dragItem->startPos();
2349                         if (m_dragItemInfo.track == info.track && !item->baseClip()->isTransparent() && getClipItemAtEnd(newTrInfo.endPos, m_document->tracksCount() - tr->transitionEndTrack())) {
2350                             // transition end should stay the same
2351                         } else {
2352                             // transition end should be adjusted to clip
2353                             newTrInfo.endPos = newTrInfo.endPos + (newTrInfo.startPos - trInfo.startPos);
2354                         }
2355                         if (newTrInfo.startPos < newTrInfo.endPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2356                     }
2357                     if (tr == NULL || tr->endPos() < m_dragItemInfo.endPos) {
2358                         // Check if there is a transition at clip end
2359                         tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track);
2360                         if (tr && tr->isAutomatic()) {
2361                             ItemInfo trInfo = tr->info();
2362                             ItemInfo newTrInfo = trInfo;
2363                             newTrInfo.track = info.track;
2364                             newTrInfo.endPos = m_dragItem->endPos();
2365                             if (m_dragItemInfo.track == info.track && !item->baseClip()->isTransparent() && getClipItemAtStart(trInfo.startPos, m_document->tracksCount() - tr->transitionEndTrack())) {
2366                                 // transition start should stay the same
2367                             } else {
2368                                 // transition start should be moved
2369                                 newTrInfo.startPos = newTrInfo.startPos + (newTrInfo.endPos - trInfo.endPos);
2370                             }
2371                             if (newTrInfo.startPos < newTrInfo.endPos)
2372                                 new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2373                         }
2374                     }
2375                     // Also move automatic transitions (on upper track)
2376                     tr = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2377                     if (m_dragItemInfo.track == info.track && tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
2378                         ItemInfo trInfo = tr->info();
2379                         ItemInfo newTrInfo = trInfo;
2380                         newTrInfo.startPos = m_dragItem->startPos();
2381                         ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2382                         if (!upperClip || !upperClip->baseClip()->isTransparent()) {
2383                             if (!getClipItemAtEnd(newTrInfo.endPos, tr->track())) {
2384                                 // transition end should be adjusted to clip on upper track
2385                                 newTrInfo.endPos = newTrInfo.endPos + (newTrInfo.startPos - trInfo.startPos);
2386                             }
2387                             if (newTrInfo.startPos < newTrInfo.endPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2388                         }
2389                     }
2390                     if (m_dragItemInfo.track == info.track && (tr == NULL || tr->endPos() < m_dragItemInfo.endPos)) {
2391                         // Check if there is a transition at clip end
2392                         tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
2393                         if (tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
2394                             ItemInfo trInfo = tr->info();
2395                             ItemInfo newTrInfo = trInfo;
2396                             newTrInfo.endPos = m_dragItem->endPos();
2397                             ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2398                             if (!upperClip || !upperClip->baseClip()->isTransparent()) {
2399                                 if (!getClipItemAtStart(trInfo.startPos, tr->track())) {
2400                                     // transition start should be moved
2401                                     newTrInfo.startPos = newTrInfo.startPos + (newTrInfo.endPos - trInfo.endPos);
2402                                 }
2403                                 if (newTrInfo.startPos < newTrInfo.endPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2404                             }
2405                         }
2406                     }
2407                     m_commandStack->push(moveCommand);
2408                 } else {
2409                     // undo last move and emit error message
2410                     bool snap = KdenliveSettings::snaptopoints();
2411                     KdenliveSettings::setSnaptopoints(false);
2412                     item->setPos((int) m_dragItemInfo.startPos.frames(m_document->fps()), (int)(m_dragItemInfo.track * m_tracksHeight + 1));
2413                     KdenliveSettings::setSnaptopoints(snap);
2414                     emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(m_dragItemInfo.startPos.frames(m_document->fps()))), ErrorMessage);
2415                 }
2416                 setDocumentModified();
2417             }
2418             if (m_dragItem->type() == TRANSITIONWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
2419                 Transition *transition = static_cast <Transition *>(m_dragItem);
2420                 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)) {
2421                     // Moving transition failed, revert to previous position
2422                     emit displayMessage(i18n("Cannot move transition"), ErrorMessage);
2423                     transition->setPos((int) m_dragItemInfo.startPos.frames(m_document->fps()), (m_dragItemInfo.track) * m_tracksHeight + 1);
2424                 } else {
2425                     MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
2426                     m_commandStack->push(command);
2427                     transition->updateTransitionEndTrack(getPreviousVideoTrack(m_dragItem->track()));
2428                 }
2429             }
2430         } else {
2431             // Moving several clips. We need to delete them and readd them to new position,
2432             // or they might overlap each other during the move
2433             QGraphicsItemGroup *group = static_cast <QGraphicsItemGroup *>(m_dragItem->parentItem());
2434             QList<QGraphicsItem *> items = group->childItems();
2435
2436             QList<ItemInfo> clipsToMove;
2437             QList<ItemInfo> transitionsToMove;
2438
2439             GenTime timeOffset = GenTime(m_dragItem->scenePos().x(), m_document->fps()) - m_dragItemInfo.startPos;
2440             const int trackOffset = (int)(m_dragItem->scenePos().y() / m_tracksHeight) - m_dragItemInfo.track;
2441             //kDebug() << "// MOVED SEVERAL CLIPS" << timeOffset.frames(25);
2442             if (timeOffset != GenTime() || trackOffset != 0) {
2443                 // remove items in MLT playlist
2444
2445                 // Expand groups
2446                 int max = items.count();
2447                 for (int i = 0; i < max; i++) {
2448                     if (items.at(i)->type() == GROUPWIDGET) {
2449                         items += items.at(i)->childItems();
2450                     }
2451                 }
2452
2453                 for (int i = 0; i < items.count(); i++) {
2454                     if (items.at(i)->type() != AVWIDGET && items.at(i)->type() != TRANSITIONWIDGET) continue;
2455                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2456                     ItemInfo info = item->info();
2457                     if (item->type() == AVWIDGET) {
2458                         if (m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
2459                             // error, clip cannot be removed from playlist
2460                             emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
2461                         } else {
2462                             clipsToMove.append(info);
2463                         }
2464                     } else {
2465                         transitionsToMove.append(info);
2466                         Transition *tr = static_cast <Transition*>(item);
2467                         m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2468                     }
2469                 }
2470
2471                 for (int i = 0; i < items.count(); i++) {
2472                     // re-add items in correct place
2473                     if (items.at(i)->type() != AVWIDGET && items.at(i)->type() != TRANSITIONWIDGET) continue;
2474                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2475                     item->updateItem();
2476                     ItemInfo info = item->info();
2477                     int tracknumber = m_document->tracksCount() - info.track - 1;
2478                     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2479                     if (isLocked) {
2480                         group->removeFromGroup(item);
2481                         item->setItemLocked(true);
2482                     }
2483
2484                     if (item->type() == AVWIDGET) {
2485                         ClipItem *clip = static_cast <ClipItem*>(item);
2486                         info.track = m_document->tracksCount() - info.track;
2487                         Mlt::Producer *prod;
2488                         if (clip->isAudioOnly()) prod = clip->baseClip()->audioProducer(info.track);
2489                         else if (clip->isVideoOnly()) prod = clip->baseClip()->videoProducer();
2490                         else prod = clip->baseClip()->producer(info.track);
2491                         m_document->renderer()->mltInsertClip(info, clip->xml(), prod);
2492                         for (int i = 0; i < clip->effectsCount(); i++) {
2493                             m_document->renderer()->mltAddEffect(info.track, info.startPos, clip->getEffectArgs(clip->effectAt(i)), false);
2494                         }
2495                     } else {
2496                         Transition *tr = static_cast <Transition*>(item);
2497                         int newTrack = tr->transitionEndTrack();
2498                         if (!tr->forcedTrack()) {
2499                             newTrack = getPreviousVideoTrack(info.track);
2500                         }
2501                         tr->updateTransitionEndTrack(newTrack);
2502                         m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2503                     }
2504                 }
2505
2506                 MoveGroupCommand *move = new MoveGroupCommand(this, clipsToMove, transitionsToMove, timeOffset, trackOffset, false);
2507                 m_commandStack->push(move);
2508
2509                 //QPointF top = group->sceneBoundingRect().topLeft();
2510                 //QPointF oldpos = m_selectionGroup->scenePos();
2511                 //kDebug()<<"SELECTION GRP POS: "<<m_selectionGroup->scenePos()<<", TOP: "<<top;
2512                 //group->setPos(top);
2513                 //TODO: get rid of the 3 lines below
2514                 if (m_selectionGroup) {
2515                     m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
2516                     m_selectionGroupInfo.track = m_selectionGroup->track();
2517                 }
2518                 setDocumentModified();
2519             }
2520         }
2521         m_document->renderer()->doRefresh();
2522     } else if (m_operationMode == RESIZESTART && m_dragItem->startPos() != m_dragItemInfo.startPos) {
2523         // resize start
2524         if (m_dragItem->type() == AVWIDGET) {
2525             ItemInfo resizeinfo = m_dragItemInfo;
2526             resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
2527             bool success = m_document->renderer()->mltResizeClipStart(resizeinfo, m_dragItem->startPos() - m_dragItemInfo.startPos);
2528             if (success) {
2529                 QUndoCommand *resizeCommand = new QUndoCommand();
2530                 resizeCommand->setText(i18n("Resize clip"));
2531
2532                 // Check if there is an automatic transition on that clip (lower track)
2533                 Transition *transition = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track);
2534                 if (transition && transition->isAutomatic()) {
2535                     ItemInfo trInfo = transition->info();
2536                     ItemInfo newTrInfo = trInfo;
2537                     newTrInfo.startPos = m_dragItem->startPos();
2538                     if (newTrInfo.startPos < newTrInfo.endPos)
2539                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2540                 }
2541                 // Check if there is an automatic transition on that clip (upper track)
2542                 transition = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2543                 if (transition && transition->isAutomatic() && (m_document->tracksCount() - transition->transitionEndTrack()) == m_dragItemInfo.track) {
2544                     ItemInfo trInfo = transition->info();
2545                     ItemInfo newTrInfo = trInfo;
2546                     newTrInfo.startPos = m_dragItem->startPos();
2547                     ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2548                     if ((!upperClip || !upperClip->baseClip()->isTransparent()) && newTrInfo.startPos < newTrInfo.endPos) {
2549                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2550                     }
2551                 }
2552                 updateClipFade(static_cast <ClipItem *>(m_dragItem));
2553                 new ResizeClipCommand(this, m_dragItemInfo, info, false, resizeCommand);
2554                 m_commandStack->push(resizeCommand);
2555             } else {
2556                 m_dragItem->resizeStart((int) m_dragItemInfo.startPos.frames(m_document->fps()));
2557                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2558             }
2559         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
2560             Transition *transition = static_cast <Transition *>(m_dragItem);
2561             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)) {
2562                 // Cannot resize transition
2563                 transition->resizeStart((int) m_dragItemInfo.startPos.frames(m_document->fps()));
2564                 emit displayMessage(i18n("Cannot resize transition"), ErrorMessage);
2565             } else {
2566                 MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
2567                 m_commandStack->push(command);
2568             }
2569
2570         }
2571         if (m_dragItem->parentItem() && m_dragItem->parentItem() != m_selectionGroup) {
2572             // Item was resized, rebuild group;
2573             AbstractGroupItem *group = static_cast <AbstractGroupItem *>(m_dragItem->parentItem());
2574             QList <QGraphicsItem *> children = group->childItems();
2575             m_document->clipManager()->removeGroup(group);
2576             scene()->destroyItemGroup(group);
2577             for (int i = 0; i < children.count(); i++) {
2578                 children.at(i)->setSelected(true);
2579             }
2580             groupSelectedItems(false, true);
2581         }
2582         //m_document->renderer()->doRefresh();
2583     } else if (m_operationMode == RESIZEEND && m_dragItem->endPos() != m_dragItemInfo.endPos) {
2584         // resize end
2585         if (m_dragItem->type() == AVWIDGET) {
2586             ItemInfo resizeinfo = info;
2587             resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
2588             bool success = m_document->renderer()->mltResizeClipEnd(resizeinfo, resizeinfo.endPos - resizeinfo.startPos);
2589             if (success) {
2590                 QUndoCommand *resizeCommand = new QUndoCommand();
2591                 resizeCommand->setText(i18n("Resize clip"));
2592
2593                 // Check if there is an automatic transition on that clip (lower track)
2594                 Transition *tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track);
2595                 if (tr && tr->isAutomatic()) {
2596                     ItemInfo trInfo = tr->info();
2597                     ItemInfo newTrInfo = trInfo;
2598                     newTrInfo.endPos = m_dragItem->endPos();
2599                     if (newTrInfo.endPos > newTrInfo.startPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2600                 }
2601
2602                 // Check if there is an automatic transition on that clip (upper track)
2603                 tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
2604                 if (tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
2605                     ItemInfo trInfo = tr->info();
2606                     ItemInfo newTrInfo = trInfo;
2607                     newTrInfo.endPos = m_dragItem->endPos();
2608                     ClipItem * upperClip = getClipItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
2609                     if ((!upperClip || !upperClip->baseClip()->isTransparent()) && newTrInfo.endPos > newTrInfo.startPos) {
2610                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2611                     }
2612                 }
2613
2614                 new ResizeClipCommand(this, m_dragItemInfo, info, false, resizeCommand);
2615                 m_commandStack->push(resizeCommand);
2616                 updateClipFade(static_cast <ClipItem *>(m_dragItem));
2617             } else {
2618                 m_dragItem->resizeEnd((int) m_dragItemInfo.endPos.frames(m_document->fps()));
2619                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2620             }
2621         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
2622             Transition *transition = static_cast <Transition *>(m_dragItem);
2623             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)) {
2624                 // Cannot resize transition
2625                 transition->resizeEnd((int) m_dragItemInfo.endPos.frames(m_document->fps()));
2626                 emit displayMessage(i18n("Cannot resize transition"), ErrorMessage);
2627             } else {
2628                 MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
2629                 m_commandStack->push(command);
2630             }
2631         }
2632         if (m_dragItem->parentItem() && m_dragItem->parentItem() != m_selectionGroup) {
2633             // Item was resized, rebuild group;
2634             AbstractGroupItem *group = static_cast <AbstractGroupItem *>(m_dragItem->parentItem());
2635             QList <QGraphicsItem *> children = group->childItems();
2636             m_document->clipManager()->removeGroup(group);
2637             scene()->destroyItemGroup(group);
2638             for (int i = 0; i < children.count(); i++) {
2639                 children.at(i)->setSelected(true);
2640             }
2641             groupSelectedItems(false, true);
2642         }
2643         //m_document->renderer()->doRefresh();
2644     } else if (m_operationMode == FADEIN) {
2645         // resize fade in effect
2646         ClipItem * item = (ClipItem *) m_dragItem;
2647         int ix = item->hasEffect("volume", "fadein");
2648         if (ix != -1) {
2649             QDomElement oldeffect = item->effectAt(ix);
2650             int start = item->cropStart().frames(m_document->fps());
2651             int end = item->fadeIn();
2652             if (end == 0) {
2653                 slotDeleteEffect(item, oldeffect);
2654             } else {
2655                 end += start;
2656                 QDomElement effect = oldeffect.cloneNode().toElement();
2657                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2658                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2659                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2660                 emit clipItemSelected(item, ix);
2661             }
2662         } else if (item->fadeIn() != 0 && item->hasEffect("", "fade_from_black") == -1) {
2663             QDomElement effect = MainWindow::audioEffects.getEffectByTag("volume", "fadein").cloneNode().toElement();
2664             EffectsList::setParameter(effect, "out", QString::number(item->fadeIn()));
2665             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
2666         }
2667         ix = item->hasEffect("volume", "fade_from_black");
2668         if (ix != -1) {
2669             QDomElement oldeffect = item->effectAt(ix);
2670             int start = item->cropStart().frames(m_document->fps());
2671             int end = item->fadeIn();
2672             if (end == 0) {
2673                 slotDeleteEffect(item, oldeffect);
2674             } else {
2675                 end += start;
2676                 QDomElement effect = oldeffect.cloneNode().toElement();
2677                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2678                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2679                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2680                 emit clipItemSelected(item, ix);
2681             }
2682         }
2683     } else if (m_operationMode == FADEOUT) {
2684         // resize fade in effect
2685         ClipItem * item = (ClipItem *) m_dragItem;
2686         int ix = item->hasEffect("volume", "fadeout");
2687         if (ix != -1) {
2688             QDomElement oldeffect = item->effectAt(ix);
2689             int end = (item->cropDuration() + item->cropStart()).frames(m_document->fps());
2690             int start = item->fadeOut();
2691             if (start == 0) {
2692                 slotDeleteEffect(item, oldeffect);
2693             } else {
2694                 start = end - start;
2695                 QDomElement effect = oldeffect.cloneNode().toElement();
2696                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2697                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2698                 // kDebug()<<"EDIT FADE OUT : "<<start<<"x"<<end;
2699                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2700                 emit clipItemSelected(item, ix);
2701             }
2702         } else if (item->fadeOut() != 0 && item->hasEffect("", "fade_to_black") == -1) {
2703             QDomElement effect = MainWindow::audioEffects.getEffectByTag("volume", "fadeout").cloneNode().toElement();
2704             EffectsList::setParameter(effect, "in", QString::number(item->fadeOut()));
2705             EffectsList::setParameter(effect, "out", QString::number(0));
2706             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
2707         }
2708         ix = item->hasEffect("brightness", "fade_to_black");
2709         if (ix != -1) {
2710             QDomElement oldeffect = item->effectAt(ix);
2711             int end = (item->cropDuration() + item->cropStart()).frames(m_document->fps());
2712             int start = item->fadeOut();
2713             if (start == 0) {
2714                 slotDeleteEffect(item, oldeffect);
2715             } else {
2716                 start = end - start;
2717                 QDomElement effect = oldeffect.cloneNode().toElement();
2718                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2719                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2720                 // kDebug()<<"EDIT FADE OUT : "<<start<<"x"<<end;
2721                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2722                 emit clipItemSelected(item, ix);
2723             }
2724         }
2725     } else if (m_operationMode == KEYFRAME) {
2726         // update the MLT effect
2727         ClipItem * item = (ClipItem *) m_dragItem;
2728         QString previous = item->keyframes(item->selectedEffectIndex());
2729         item->updateKeyframeEffect();
2730         QString next = item->keyframes(item->selectedEffectIndex());
2731         EditKeyFrameCommand *command = new EditKeyFrameCommand(this, item->track(), item->startPos(), item->selectedEffectIndex(), previous, next, false);
2732         m_commandStack->push(command);
2733         updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
2734         emit clipItemSelected(item, item->selectedEffectIndex());
2735     }
2736     if (m_dragItem && m_dragItem->type() == TRANSITIONWIDGET && m_dragItem->isSelected()) {
2737         // A transition is selected
2738         QPoint p;
2739         ClipItem *transitionClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track);
2740         if (transitionClip && transitionClip->baseClip()) {
2741             QString size = transitionClip->baseClip()->getProperty("frame_size");
2742             p.setX(size.section('x', 0, 0).toInt());
2743             p.setY(size.section('x', 1, 1).toInt());
2744         }
2745         emit transitionItemSelected(static_cast <Transition *>(m_dragItem), getPreviousVideoTrack(m_dragItem->track()), p);
2746     } else emit transitionItemSelected(NULL);
2747     if (m_operationMode != NONE && m_operationMode != MOVE) setDocumentModified();
2748     m_operationMode = NONE;
2749 }
2750
2751 void CustomTrackView::deleteClip(ItemInfo info)
2752 {
2753     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
2754
2755     if (!item || m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
2756         emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
2757         return;
2758     }
2759     if (item->isSelected()) emit clipItemSelected(NULL);
2760     item->baseClip()->removeReference();
2761     m_document->updateClip(item->baseClip()->getId());
2762
2763     /*if (item->baseClip()->isTransparent()) {
2764         // also remove automatic transition
2765         Transition *tr = getTransitionItemAt(info.startPos, info.track);
2766         if (tr && tr->isAutomatic()) {
2767             m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2768             scene()->removeItem(tr);
2769             delete tr;
2770         }
2771     }*/
2772     scene()->removeItem(item);
2773     m_waitingThumbs.removeAll(item);
2774     if (m_dragItem == item) m_dragItem = NULL;
2775     delete item;
2776     item = NULL;
2777     setDocumentModified();
2778     m_document->renderer()->doRefresh();
2779 }
2780
2781 void CustomTrackView::deleteSelectedClips()
2782 {
2783     resetSelectionGroup();
2784     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2785     if (itemList.count() == 0) {
2786         emit displayMessage(i18n("Select clip to delete"), ErrorMessage);
2787         return;
2788     }
2789     scene()->clearSelection();
2790     QUndoCommand *deleteSelected = new QUndoCommand();
2791     deleteSelected->setText(i18n("Delete selected items"));
2792     bool resetGroup = false;
2793
2794     // expand & destroy groups
2795     for (int i = 0; i < itemList.count(); i++) {
2796         if (itemList.at(i)->type() == GROUPWIDGET) {
2797             QList<QGraphicsItem *> children = itemList.at(i)->childItems();
2798             itemList += children;
2799             QList <ItemInfo> clipInfos;
2800             QList <ItemInfo> transitionInfos;
2801             GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
2802             for (int j = 0; j < children.count(); j++) {
2803                 if (children.at(j)->type() == AVWIDGET) {
2804                     AbstractClipItem *clip = static_cast <AbstractClipItem *>(children.at(j));
2805                     if (!clip->isItemLocked()) clipInfos.append(clip->info());
2806                 } else if (children.at(j)->type() == TRANSITIONWIDGET) {
2807                     AbstractClipItem *clip = static_cast <AbstractClipItem *>(children.at(j));
2808                     if (!clip->isItemLocked()) transitionInfos.append(clip->info());
2809                 }
2810             }
2811             if (clipInfos.count() > 0) {
2812                 new GroupClipsCommand(this, clipInfos, transitionInfos, false, deleteSelected);
2813             }
2814         }
2815     }
2816
2817     for (int i = 0; i < itemList.count(); i++) {
2818         if (itemList.at(i)->type() == AVWIDGET) {
2819             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2820             if (item->parentItem()) resetGroup = true;
2821             //kDebug()<<"// DELETE CLP AT: "<<item->info().startPos.frames(25);
2822             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true, deleteSelected);
2823             emit clipItemSelected(NULL);
2824         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
2825             Transition *item = static_cast <Transition *>(itemList.at(i));
2826             //kDebug()<<"// DELETE TRANS AT: "<<item->info().startPos.frames(25);
2827             if (item->parentItem()) resetGroup = true;
2828             new AddTransitionCommand(this, item->info(), item->transitionEndTrack(), item->toXML(), true, true, deleteSelected);
2829             emit transitionItemSelected(NULL);
2830         }
2831     }
2832
2833     m_commandStack->push(deleteSelected);
2834 }
2835
2836 void CustomTrackView::changeClipSpeed()
2837 {
2838     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2839     if (itemList.count() == 0) {
2840         emit displayMessage(i18n("Select clip to change speed"), ErrorMessage);
2841         return;
2842     }
2843     QUndoCommand *changeSelected = new QUndoCommand();
2844     changeSelected->setText("Edit clip speed");
2845     int count = 0;
2846     int percent = -1;
2847     bool ok;
2848     for (int i = 0; i < itemList.count(); i++) {
2849         if (itemList.at(i)->type() == AVWIDGET) {
2850             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2851             ItemInfo info = item->info();
2852             if (percent == -1) percent = QInputDialog::getInteger(this, i18n("Edit Clip Speed"), i18n("New speed (percents)"), item->speed() * 100, 1, 10000, 1, &ok);
2853             if (!ok) break;
2854             double speed = (double) percent / 100.0;
2855             if (item->speed() != speed && (item->clipType() == VIDEO || item->clipType() == AV)) {
2856                 count++;
2857                 new ChangeSpeedCommand(this, info, item->speed(), speed, item->clipProducer(), changeSelected);
2858             }
2859         }
2860     }
2861     if (count > 0) m_commandStack->push(changeSelected);
2862     else delete changeSelected;
2863 }
2864
2865 void CustomTrackView::doChangeClipSpeed(ItemInfo info, const double speed, const double oldspeed, const QString &id)
2866 {
2867     DocClipBase *baseclip = m_document->clipManager()->getClipById(id);
2868     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
2869     if (!item) {
2870         kDebug() << "ERROR: Cannot find clip for speed change";
2871         emit displayMessage(i18n("Cannot find clip for speed change"), ErrorMessage);
2872         return;
2873     }
2874     info.track = m_document->tracksCount() - item->track();
2875     int endPos = m_document->renderer()->mltChangeClipSpeed(info, speed, oldspeed, baseclip->producer());
2876     if (endPos >= 0) {
2877         item->setSpeed(speed);
2878         item->updateRectGeometry();
2879         if (item->cropDuration().frames(m_document->fps()) > endPos)
2880             item->AbstractClipItem::resizeEnd(info.startPos.frames(m_document->fps()) + endPos, speed);
2881         setDocumentModified();
2882     } else emit displayMessage(i18n("Invalid clip"), ErrorMessage);
2883 }
2884
2885 void CustomTrackView::cutSelectedClips()
2886 {
2887     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2888     GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
2889     for (int i = 0; i < itemList.count(); i++) {
2890         if (itemList.at(i)->type() == AVWIDGET) {
2891             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2892             if (item->parentItem() && item->parentItem() != m_selectionGroup) {
2893                 emit displayMessage(i18n("Cannot cut a clip in a group"), ErrorMessage);
2894             } else if (currentPos > item->startPos() && currentPos <  item->endPos()) {
2895                 RazorClipCommand *command = new RazorClipCommand(this, item->info(), currentPos);
2896                 m_commandStack->push(command);
2897             }
2898         }
2899     }
2900 }
2901
2902 void CustomTrackView::groupClips(bool group)
2903 {
2904     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2905     QList <ItemInfo> clipInfos;
2906     QList <ItemInfo> transitionInfos;
2907     GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
2908
2909     // Expand groups
2910     int max = itemList.count();
2911     for (int i = 0; i < max; i++) {
2912         if (itemList.at(i)->type() == GROUPWIDGET) {
2913             itemList += itemList.at(i)->childItems();
2914         }
2915     }
2916
2917     for (int i = 0; i < itemList.count(); i++) {
2918         if (itemList.at(i)->type() == AVWIDGET) {
2919             AbstractClipItem *clip = static_cast <AbstractClipItem *>(itemList.at(i));
2920             if (!clip->isItemLocked()) clipInfos.append(clip->info());
2921         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
2922             AbstractClipItem *clip = static_cast <AbstractClipItem *>(itemList.at(i));
2923             if (!clip->isItemLocked()) transitionInfos.append(clip->info());
2924         }
2925     }
2926     if (clipInfos.count() > 0) {
2927         GroupClipsCommand *command = new GroupClipsCommand(this, clipInfos, transitionInfos, group);
2928         m_commandStack->push(command);
2929     }
2930 }
2931
2932 void CustomTrackView::doGroupClips(QList <ItemInfo> clipInfos, QList <ItemInfo> transitionInfos, bool group)
2933 {
2934     resetSelectionGroup();
2935     m_scene->clearSelection();
2936     if (!group) {
2937         for (int i = 0; i < clipInfos.count(); i++) {
2938             ClipItem *clip = getClipItemAt(clipInfos.at(i).startPos, clipInfos.at(i).track);
2939             if (clip == NULL) continue;
2940             if (clip->parentItem() && clip->parentItem()->type() == GROUPWIDGET) {
2941                 AbstractGroupItem *grp = static_cast <AbstractGroupItem *>(clip->parentItem());
2942                 m_document->clipManager()->removeGroup(grp);
2943                 scene()->destroyItemGroup(grp);
2944             }
2945             clip->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
2946         }
2947         for (int i = 0; i < transitionInfos.count(); i++) {
2948             Transition *tr = getTransitionItemAt(transitionInfos.at(i).startPos, transitionInfos.at(i).track);
2949             if (tr == NULL) continue;
2950             if (tr->parentItem() && tr->parentItem()->type() == GROUPWIDGET) {
2951                 AbstractGroupItem *grp = static_cast <AbstractGroupItem *>(tr->parentItem());
2952                 m_document->clipManager()->removeGroup(grp);
2953                 scene()->destroyItemGroup(grp);
2954             }
2955             tr->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
2956         }
2957         setDocumentModified();
2958         return;
2959     }
2960
2961     QList <QGraphicsItemGroup *> groups;
2962     for (int i = 0; i < clipInfos.count(); i++) {
2963         ClipItem *clip = getClipItemAt(clipInfos.at(i).startPos, clipInfos.at(i).track);
2964         if (clip) {
2965             clip->setSelected(true);
2966         }
2967     }
2968     for (int i = 0; i < transitionInfos.count(); i++) {
2969         Transition *clip = getTransitionItemAt(transitionInfos.at(i).startPos, transitionInfos.at(i).track);
2970         if (clip) {
2971             clip->setSelected(true);
2972         }
2973     }
2974
2975     groupSelectedItems(false, true);
2976     setDocumentModified();
2977 }
2978
2979 void CustomTrackView::addClip(QDomElement xml, const QString &clipId, ItemInfo info, EffectsList effects)
2980 {
2981     DocClipBase *baseclip = m_document->clipManager()->getClipById(clipId);
2982     if (baseclip == NULL) {
2983         emit displayMessage(i18n("No clip copied"), ErrorMessage);
2984         return;
2985     }
2986     ClipItem *item = new ClipItem(baseclip, info, m_document->fps(), xml.attribute("speed", "1").toDouble());
2987     item->setEffectList(effects);
2988     if (xml.hasAttribute("audio_only")) item->setAudioOnly(true);
2989     else if (xml.hasAttribute("video_only")) item->setVideoOnly(true);
2990     scene()->addItem(item);
2991
2992     int tracknumber = m_document->tracksCount() - info.track - 1;
2993     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2994     if (isLocked) item->setItemLocked(true);
2995
2996     baseclip->addReference();
2997     m_document->updateClip(baseclip->getId());
2998     info.track = m_document->tracksCount() - info.track;
2999     Mlt::Producer *prod;
3000     if (item->isAudioOnly()) prod = baseclip->audioProducer(info.track);
3001     else if (item->isVideoOnly()) prod = baseclip->videoProducer();
3002     else prod = baseclip->producer(info.track);
3003     m_document->renderer()->mltInsertClip(info, xml, prod);
3004     for (int i = 0; i < item->effectsCount(); i++) {
3005         m_document->renderer()->mltAddEffect(info.track, info.startPos, item->getEffectArgs(item->effectAt(i)), false);
3006     }
3007     setDocumentModified();
3008     m_document->renderer()->doRefresh();
3009     m_waitingThumbs.append(item);
3010     m_thumbsTimer.start();
3011 }
3012
3013 void CustomTrackView::slotUpdateClip(const QString &clipId)
3014 {
3015     QList<QGraphicsItem *> list = scene()->items();
3016     ClipItem *clip = NULL;
3017     for (int i = 0; i < list.size(); ++i) {
3018         if (list.at(i)->type() == AVWIDGET) {
3019             clip = static_cast <ClipItem *>(list.at(i));
3020             if (clip->clipProducer() == clipId) {
3021                 ItemInfo info = clip->info();
3022                 info.track = m_document->tracksCount() - clip->track();
3023                 m_document->renderer()->mltUpdateClip(info, clip->xml(), clip->baseClip()->producer());
3024                 clip->refreshClip(true);
3025                 clip->update();
3026             }
3027         }
3028     }
3029 }
3030
3031 ClipItem *CustomTrackView::getClipItemAtEnd(GenTime pos, int track)
3032 {
3033     int framepos = (int)(pos.frames(m_document->fps()));
3034     QList<QGraphicsItem *> list = scene()->items(QPointF(framepos - 1, track * m_tracksHeight + m_tracksHeight / 2));
3035     ClipItem *clip = NULL;
3036     for (int i = 0; i < list.size(); i++) {
3037         if (list.at(i)->type() == AVWIDGET) {
3038             ClipItem *test = static_cast <ClipItem *>(list.at(i));
3039             if (test->endPos() == pos) clip = test;
3040             break;
3041         }
3042     }
3043     return clip;
3044 }
3045
3046 ClipItem *CustomTrackView::getClipItemAtStart(GenTime pos, int track)
3047 {
3048     QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), track * m_tracksHeight + m_tracksHeight / 2));
3049     ClipItem *clip = NULL;
3050     for (int i = 0; i < list.size(); i++) {
3051         if (list.at(i)->type() == AVWIDGET) {
3052             ClipItem *test = static_cast <ClipItem *>(list.at(i));
3053             if (test->startPos() == pos) clip = test;
3054             break;
3055         }
3056     }
3057     return clip;
3058 }
3059
3060 ClipItem *CustomTrackView::getClipItemAt(int pos, int track)
3061 {
3062     QList<QGraphicsItem *> list = scene()->items(QPointF(pos, track * m_tracksHeight + m_tracksHeight / 2));
3063     ClipItem *clip = NULL;
3064     for (int i = 0; i < list.size(); i++) {
3065         if (list.at(i)->type() == AVWIDGET) {
3066             clip = static_cast <ClipItem *>(list.at(i));
3067             break;
3068         }
3069     }
3070     return clip;
3071 }
3072
3073 ClipItem *CustomTrackView::getClipItemAt(GenTime pos, int track)
3074 {
3075     int framepos = (int)(pos.frames(m_document->fps()));
3076     return getClipItemAt(framepos, track);
3077 }
3078
3079 Transition *CustomTrackView::getTransitionItemAt(int pos, int track)
3080 {
3081     QList<QGraphicsItem *> list = scene()->items(QPointF(pos, (track + 1) * m_tracksHeight));
3082     Transition *clip = NULL;
3083     for (int i = 0; i < list.size(); i++) {
3084         if (list.at(i)->type() == TRANSITIONWIDGET) {
3085             clip = static_cast <Transition *>(list.at(i));
3086             break;
3087         }
3088     }
3089     return clip;
3090 }
3091
3092 Transition *CustomTrackView::getTransitionItemAt(GenTime pos, int track)
3093 {
3094     return getTransitionItemAt(pos.frames(m_document->fps()), track);
3095 }
3096
3097 Transition *CustomTrackView::getTransitionItemAtEnd(GenTime pos, int track)
3098 {
3099     int framepos = (int)(pos.frames(m_document->fps()));
3100     QList<QGraphicsItem *> list = scene()->items(QPointF(framepos - 1, (track + 1) * m_tracksHeight));
3101     Transition *clip = NULL;
3102     for (int i = 0; i < list.size(); i++) {
3103         if (list.at(i)->type() == TRANSITIONWIDGET) {
3104             Transition *test = static_cast <Transition *>(list.at(i));
3105             if (test->endPos() == pos) clip = test;
3106             break;
3107         }
3108     }
3109     return clip;
3110 }
3111
3112 Transition *CustomTrackView::getTransitionItemAtStart(GenTime pos, int track)
3113 {
3114     QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), (track + 1) * m_tracksHeight));
3115     Transition *clip = NULL;
3116     for (int i = 0; i < list.size(); ++i) {
3117         if (list.at(i)->type() == TRANSITIONWIDGET) {
3118             Transition *test = static_cast <Transition *>(list.at(i));
3119             if (test->startPos() == pos) clip = test;
3120             break;
3121         }
3122     }
3123     return clip;
3124 }
3125
3126 void CustomTrackView::moveClip(const ItemInfo start, const ItemInfo end)
3127 {
3128     if (m_selectionGroup) resetSelectionGroup(false);
3129     ClipItem *item = getClipItemAt((int) start.startPos.frames(m_document->fps()) + 1, start.track);
3130     if (!item) {
3131         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);
3132         kDebug() << "----------------  ERROR, CANNOT find clip to move at.. ";
3133         return;
3134     }
3135     Mlt::Producer *prod;
3136     if (item->isAudioOnly()) prod = item->baseClip()->audioProducer(end.track);
3137     else if (item->isVideoOnly()) prod = item->baseClip()->videoProducer();
3138     else prod = item->baseClip()->producer(end.track);
3139
3140     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);
3141     if (success) {
3142         bool snap = KdenliveSettings::snaptopoints();
3143         KdenliveSettings::setSnaptopoints(false);
3144         item->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
3145
3146         int tracknumber = m_document->tracksCount() - end.track - 1;
3147         bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
3148         m_scene->clearSelection();
3149         if (isLocked) item->setItemLocked(true);
3150         else {
3151             if (item->isItemLocked()) item->setItemLocked(false);
3152             item->setSelected(true);
3153         }
3154         if (item->baseClip()->isTransparent()) {
3155             // Also move automatic transition
3156             Transition *tr = getTransitionItemAt(start.startPos, start.track);
3157             if (tr && tr->isAutomatic()) {
3158                 tr->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
3159                 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);
3160                 tr->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
3161             }
3162         }
3163         KdenliveSettings::setSnaptopoints(snap);
3164         setDocumentModified();
3165     } else {
3166         // undo last move and emit error message
3167         emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(end.startPos.frames(m_document->fps()))), ErrorMessage);
3168     }
3169     m_document->renderer()->doRefresh();
3170     //kDebug() << " // MOVED CLIP TO: " << end.startPos.frames(25) << ", ITEM START: " << item->startPos().frames(25);
3171 }
3172
3173 void CustomTrackView::moveGroup(QList <ItemInfo> startClip, QList <ItemInfo> startTransition, const GenTime offset, const int trackOffset, bool reverseMove)
3174 {
3175     // Group Items
3176     /*kDebug() << "//GRP MOVE, REVERS:" << reverseMove;
3177     kDebug() << "// GROUP MOV; OFFSET: " << offset.frames(25) << ", TK OFF: " << trackOffset;*/
3178     resetSelectionGroup();
3179     m_scene->clearSelection();
3180
3181     for (int i = 0; i < startClip.count(); i++) {
3182         if (reverseMove) {
3183             startClip[i].startPos = startClip.at(i).startPos - offset;
3184             startClip[i].track = startClip.at(i).track - trackOffset;
3185         }
3186         //kDebug()<<"//LKING FR CLIP AT:"<<startClip.at(i).startPos.frames(25)<<", TK:"<<startClip.at(i).track;
3187         ClipItem *clip = getClipItemAt(startClip.at(i).startPos, startClip.at(i).track);
3188         if (clip) {
3189             clip->setItemLocked(false);
3190             if (clip->parentItem()) clip->parentItem()->setSelected(true);
3191             else clip->setSelected(true);
3192             m_document->renderer()->mltRemoveClip(m_document->tracksCount() - startClip.at(i).track, startClip.at(i).startPos);
3193         } else kDebug() << "//MISSING CLIP AT: " << startClip.at(i).startPos.frames(25);
3194     }
3195     for (int i = 0; i < startTransition.count(); i++) {
3196         if (reverseMove) {
3197             startTransition[i].startPos = startTransition.at(i).startPos - offset;
3198             startTransition[i].track = startTransition.at(i).track - trackOffset;
3199         }
3200         Transition *tr = getTransitionItemAt(startTransition.at(i).startPos, startTransition.at(i).track);
3201         if (tr) {
3202             tr->setItemLocked(false);
3203             if (tr->parentItem()) tr->parentItem()->setSelected(true);
3204             else tr->setSelected(true);
3205             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());
3206         } else kDebug() << "//MISSING TRANSITION AT: " << startTransition.at(i).startPos.frames(25);
3207     }
3208     groupSelectedItems(true);
3209     if (m_selectionGroup) {
3210         bool snap = KdenliveSettings::snaptopoints();
3211         KdenliveSettings::setSnaptopoints(false);
3212
3213         m_selectionGroup->moveBy(offset.frames(m_document->fps()), trackOffset *(qreal) m_tracksHeight);
3214
3215         kDebug() << "%% GRP NEW POS: " << m_selectionGroup->scenePos().x();
3216
3217         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
3218         // Expand groups
3219         int max = children.count();
3220         for (int i = 0; i < max; i++) {
3221             if (children.at(i)->type() == GROUPWIDGET) {
3222                 children += children.at(i)->childItems();
3223             }
3224         }
3225         kDebug() << "// GRP MOVE; FOUND CHILDREN:" << children.count();
3226
3227         for (int i = 0; i < children.count(); i++) {
3228             // re-add items in correct place
3229             if (children.at(i)->type() != AVWIDGET && children.at(i)->type() != TRANSITIONWIDGET) continue;
3230             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
3231             item->updateItem();
3232             ItemInfo info = item->info();
3233             int tracknumber = m_document->tracksCount() - info.track - 1;
3234             bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
3235             if (isLocked) item->setItemLocked(true);
3236             else if (item->isItemLocked()) item->setItemLocked(false);
3237
3238             if (item->type() == AVWIDGET) {
3239                 ClipItem *clip = static_cast <ClipItem*>(item);
3240                 info.track = m_document->tracksCount() - info.track;
3241                 Mlt::Producer *prod;
3242                 if (clip->isAudioOnly()) prod = clip->baseClip()->audioProducer(info.track);
3243                 else if (clip->isVideoOnly()) prod = clip->baseClip()->videoProducer();
3244                 else prod = clip->baseClip()->producer(info.track);
3245                 m_document->renderer()->mltInsertClip(info, clip->xml(), prod);
3246                 kDebug() << "// inserting new clp: " << info.startPos.frames(25);
3247             } else if (item->type() == TRANSITIONWIDGET) {
3248                 Transition *tr = static_cast <Transition*>(item);
3249                 int newTrack = tr->transitionEndTrack();
3250                 kDebug() << "/// TRANSITION CURR TRK: " << newTrack;
3251                 if (!tr->forcedTrack()) {
3252                     newTrack += trackOffset;
3253                     if (newTrack < 0 || newTrack > m_document->tracksCount()) newTrack = getPreviousVideoTrack(info.track);
3254                 }
3255                 tr->updateTransitionEndTrack(newTrack);
3256                 kDebug() << "/// TRANSITION UPDATED TRK: " << newTrack;
3257                 m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
3258             }
3259         }
3260         KdenliveSettings::setSnaptopoints(snap);
3261         m_document->renderer()->doRefresh();
3262     } else kDebug() << "///////// WARNING; NO GROUP TO MOVE";
3263 }
3264
3265 void CustomTrackView::moveTransition(const ItemInfo start, const ItemInfo end)
3266 {
3267     Transition *item = getTransitionItemAt(start.startPos, start.track);
3268     if (!item) {
3269         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);
3270         kDebug() << "----------------  ERROR, CANNOT find transition to move... ";// << startPos.x() * m_scale * FRAME_SIZE + 1 << ", " << startPos.y() * m_tracksHeight + m_tracksHeight / 2;
3271         return;
3272     }
3273     //kDebug() << "----------------  Move TRANSITION FROM: " << startPos.x() << ", END:" << endPos.x() << ",TRACKS: " << oldtrack << " TO " << newtrack;
3274     bool snap = KdenliveSettings::snaptopoints();
3275     KdenliveSettings::setSnaptopoints(false);
3276     //kDebug()<<"///  RESIZE TRANS START: ("<< startPos.x()<<"x"<< startPos.y()<<") / ("<<endPos.x()<<"x"<< endPos.y()<<")";
3277     if (end.endPos - end.startPos == start.endPos - start.startPos) {
3278         // Transition was moved
3279         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
3280     } else if (end.endPos == start.endPos) {
3281         // Transition start resize
3282         item->resizeStart((int) end.startPos.frames(m_document->fps()));
3283     } else if (end.startPos == start.startPos) {
3284         // Transition end resize;
3285         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
3286     } else {
3287         // Move & resize
3288         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
3289         item->resizeStart((int) end.startPos.frames(m_document->fps()));
3290         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
3291     }
3292     //item->moveTransition(GenTime((int) (endPos.x() - startPos.x()), m_document->fps()));
3293     KdenliveSettings::setSnaptopoints(snap);
3294     item->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
3295     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);
3296     if (m_dragItem && m_dragItem == item) {
3297         QPoint p;
3298         ClipItem *transitionClip = getClipItemAt(item->startPos(), item->track());
3299         if (transitionClip && transitionClip->baseClip()) {
3300             QString size = transitionClip->baseClip()->getProperty("frame_size");
3301             p.setX(size.section('x', 0, 0).toInt());
3302             p.setY(size.section('x', 1, 1).toInt());
3303         }
3304         emit transitionItemSelected(item, getPreviousVideoTrack(item->track()), p);
3305     }
3306     m_document->renderer()->doRefresh();
3307 }
3308
3309 void CustomTrackView::resizeClip(const ItemInfo start, const ItemInfo end)
3310 {
3311     bool resizeClipStart = true;
3312     if (start.startPos == end.startPos) resizeClipStart = false;
3313     /*if (resizeClipStart) offset = 1;
3314     else offset = -1;*/
3315     ClipItem *item = getClipItemAt((int)(start.startPos.frames(m_document->fps())), start.track);
3316     if (!item) {
3317         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);
3318         kDebug() << "----------------  ERROR, CANNOT find clip to resize at... "; // << startPos;
3319         return;
3320     }
3321     if (item->parentItem()) {
3322         // Item is part of a group, reset group
3323         resetSelectionGroup();
3324     }
3325     bool snap = KdenliveSettings::snaptopoints();
3326     KdenliveSettings::setSnaptopoints(false);
3327     if (resizeClipStart && start.startPos != end.startPos) {
3328         ItemInfo clipinfo = item->info();
3329         clipinfo.track = m_document->tracksCount() - clipinfo.track;
3330         bool success = m_document->renderer()->mltResizeClipStart(clipinfo, end.startPos - item->startPos());
3331         if (success) {
3332             kDebug() << "RESIZE CLP STRAT TO:" << end.startPos.frames(m_document->fps()) << ", OLD ST: " << start.startPos.frames(25);
3333             item->resizeStart((int) end.startPos.frames(m_document->fps()));
3334             updateClipFade(item);
3335         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
3336     } else if (!resizeClipStart) {
3337         ItemInfo clipinfo = item->info();
3338         clipinfo.track = m_document->tracksCount() - clipinfo.track;
3339         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, end.endPos - clipinfo.startPos);
3340         if (success) {
3341             item->resizeEnd((int) end.endPos.frames(m_document->fps()));
3342             updateClipFade(item);
3343         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
3344     }
3345     if (end.cropStart != start.cropStart) {
3346         kDebug() << "// RESIZE CROP, DIFF: " << (end.cropStart - start.cropStart).frames(25);
3347         ItemInfo clipinfo = end;
3348         clipinfo.track = m_document->tracksCount() - end.track;
3349         bool success = m_document->renderer()->mltResizeClipCrop(clipinfo, end.cropStart - start.cropStart);
3350         if (success) {
3351             item->setCropStart(end.cropStart);
3352             item->resetThumbs(true);
3353         }
3354     }
3355     m_document->renderer()->doRefresh();
3356     KdenliveSettings::setSnaptopoints(snap);
3357 }
3358
3359 void CustomTrackView::updateClipFade(ClipItem * item)
3360 {
3361     int end = item->fadeIn();
3362     if (end != 0) {
3363         // there is a fade in effect
3364         int effectPos = item->hasEffect("volume", "fadein");
3365         if (effectPos != -1) {
3366             QDomElement oldeffect = item->effectAt(effectPos);
3367             int start = item->cropStart().frames(m_document->fps());
3368             int max = item->cropDuration().frames(m_document->fps());
3369             if (end > max) {
3370                 // Make sure the fade effect is not longer than the clip
3371                 item->setFadeIn(max);
3372                 end = item->fadeIn();
3373             }
3374             end += start;
3375             EffectsList::setParameter(oldeffect, "in", QString::number(start));
3376             EffectsList::setParameter(oldeffect, "out", QString::number(end));
3377             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3378                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3379             // if fade effect is displayed, update the effect edit widget with new clip duration
3380             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3381         }
3382         effectPos = item->hasEffect("brightness", "fade_from_black");
3383         if (effectPos != -1) {
3384             QDomElement oldeffect = item->effectAt(effectPos);
3385             int start = item->cropStart().frames(m_document->fps());
3386             int max = item->cropDuration().frames(m_document->fps());
3387             if (end > max) {
3388                 // Make sure the fade effect is not longer than the clip
3389                 item->setFadeIn(max);
3390                 end = item->fadeIn();
3391             }
3392             end += start;
3393             EffectsList::setParameter(oldeffect, "in", QString::number(start));
3394             EffectsList::setParameter(oldeffect, "out", QString::number(end));
3395             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3396                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3397             // if fade effect is displayed, update the effect edit widget with new clip duration
3398             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3399         }
3400     }
3401     int start = item->fadeOut();
3402     if (start != 0) {
3403         // there is a fade out effect
3404         int effectPos = item->hasEffect("volume", "fadeout");
3405         if (effectPos != -1) {
3406             QDomElement oldeffect = item->effectAt(effectPos);
3407             int max = item->cropDuration().frames(m_document->fps());
3408             int end = max + item->cropStart().frames(m_document->fps());
3409             if (start > max) {
3410                 // Make sure the fade effect is not longer than the clip
3411                 item->setFadeOut(max);
3412                 start = item->fadeOut();
3413             }
3414             start = end - start;
3415             EffectsList::setParameter(oldeffect, "in", QString::number(start));
3416             EffectsList::setParameter(oldeffect, "out", QString::number(end));
3417             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3418                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3419             // if fade effect is displayed, update the effect edit widget with new clip duration
3420             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3421         }
3422         effectPos = item->hasEffect("brightness", "fade_to_black");
3423         if (effectPos != -1) {
3424             QDomElement oldeffect = item->effectAt(effectPos);
3425             int max = item->cropDuration().frames(m_document->fps());
3426             int end = max + item->cropStart().frames(m_document->fps());
3427             if (start > max) {
3428                 // Make sure the fade effect is not longer than the clip
3429                 item->setFadeOut(max);
3430                 start = item->fadeOut();
3431             }
3432             start = end - start;
3433             EffectsList::setParameter(oldeffect, "in", QString::number(start));
3434             EffectsList::setParameter(oldeffect, "out", QString::number(end));
3435             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3436                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3437             // if fade effect is displayed, update the effect edit widget with new clip duration
3438             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3439         }
3440     }
3441 }
3442
3443 double CustomTrackView::getSnapPointForPos(double pos)
3444 {
3445     return m_scene->getSnapPointForPos(pos, KdenliveSettings::snaptopoints());
3446 }
3447
3448 void CustomTrackView::updateSnapPoints(AbstractClipItem *selected, QList <GenTime> offsetList, bool skipSelectedItems)
3449 {
3450     QList <GenTime> snaps;
3451     if (selected && offsetList.isEmpty()) offsetList.append(selected->cropDuration());
3452     QList<QGraphicsItem *> itemList = items();
3453     for (int i = 0; i < itemList.count(); i++) {
3454         if (itemList.at(i) == selected) continue;
3455         if (skipSelectedItems && itemList.at(i)->isSelected()) continue;
3456         if (itemList.at(i)->type() == AVWIDGET) {
3457             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
3458             GenTime start = item->startPos();
3459             GenTime end = item->endPos();
3460             snaps.append(start);
3461             snaps.append(end);
3462             if (!offsetList.isEmpty()) {
3463                 for (int j = 0; j < offsetList.size(); j++) {
3464                     if (start > offsetList.at(j)) snaps.append(start - offsetList.at(j));
3465                     if (end > offsetList.at(j)) snaps.append(end - offsetList.at(j));
3466                 }
3467             }
3468             // Add clip markers
3469             QList < GenTime > markers = item->snapMarkers();
3470             for (int j = 0; j < markers.size(); ++j) {
3471                 GenTime t = markers.at(j);
3472                 snaps.append(t);
3473                 if (!offsetList.isEmpty()) {
3474                     for (int k = 0; k < offsetList.size(); k++) {
3475                         if (t > offsetList.at(k)) snaps.append(t - offsetList.at(k));
3476                     }
3477                 }
3478             }
3479         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
3480             Transition *transition = static_cast <Transition*>(itemList.at(i));
3481             GenTime start = transition->startPos();
3482             GenTime end = transition->endPos();
3483             snaps.append(start);
3484             snaps.append(end);
3485             if (!offsetList.isEmpty()) {
3486                 for (int j = 0; j < offsetList.size(); j++) {
3487                     if (start > offsetList.at(j)) snaps.append(start - offsetList.at(j));
3488                     if (end > offsetList.at(j)) snaps.append(end - offsetList.at(j));
3489                 }
3490             }
3491         }
3492     }
3493
3494     // add cursor position
3495     GenTime pos = GenTime(m_cursorPos, m_document->fps());
3496     snaps.append(pos);
3497     if (!offsetList.isEmpty()) {
3498         for (int j = 0; j < offsetList.size(); j++) {
3499             snaps.append(pos - offsetList.at(j));
3500         }
3501     }
3502
3503     // add guides
3504     for (int i = 0; i < m_guides.count(); i++) {
3505         snaps.append(m_guides.at(i)->position());
3506         if (!offsetList.isEmpty()) {
3507             for (int j = 0; j < offsetList.size(); j++) {
3508                 snaps.append(m_guides.at(i)->position() - offsetList.at(j));
3509             }
3510         }
3511     }
3512
3513     qSort(snaps);
3514     m_scene->setSnapList(snaps);
3515     //for (int i = 0; i < m_snapPoints.size(); ++i)
3516     //    kDebug() << "SNAP POINT: " << m_snapPoints.at(i).frames(25);
3517 }
3518
3519 void CustomTrackView::slotSeekToPreviousSnap()
3520 {
3521     updateSnapPoints(NULL);
3522     GenTime res = m_scene->previousSnapPoint(GenTime(m_cursorPos, m_document->fps()));
3523     setCursorPos((int) res.frames(m_document->fps()));
3524     checkScrolling();
3525 }
3526
3527 void CustomTrackView::slotSeekToNextSnap()
3528 {
3529     updateSnapPoints(NULL);
3530     GenTime res = m_scene->nextSnapPoint(GenTime(m_cursorPos, m_document->fps()));
3531     setCursorPos((int) res.frames(m_document->fps()));
3532     checkScrolling();
3533 }
3534
3535 void CustomTrackView::clipStart()
3536 {
3537     ClipItem *item = getMainActiveClip();
3538     if (item != NULL) {
3539         setCursorPos((int) item->startPos().frames(m_document->fps()));
3540         checkScrolling();
3541     }
3542 }
3543
3544 void CustomTrackView::clipEnd()
3545 {
3546     ClipItem *item = getMainActiveClip();
3547     if (item != NULL) {
3548         setCursorPos((int) item->endPos().frames(m_document->fps()) - 1);
3549         checkScrolling();
3550     }
3551 }
3552
3553 void CustomTrackView::slotAddClipMarker(const QString &id, GenTime t, QString c)
3554 {
3555     QString oldcomment = m_document->clipManager()->getClipById(id)->markerComment(t);
3556     AddMarkerCommand *command = new AddMarkerCommand(this, oldcomment, c, id, t);
3557     m_commandStack->push(command);
3558 }
3559
3560 void CustomTrackView::slotDeleteClipMarker(const QString &comment, const QString &id, const GenTime &position)
3561 {
3562     AddMarkerCommand *command = new AddMarkerCommand(this, comment, QString(), id, position);
3563     m_commandStack->push(command);
3564 }
3565
3566 void CustomTrackView::slotDeleteAllClipMarkers(const QString &id)
3567 {
3568     DocClipBase *base = m_document->clipManager()->getClipById(id);
3569     QList <CommentedTime> markers = base->commentedSnapMarkers();
3570
3571     if (markers.isEmpty()) {
3572         emit displayMessage(i18n("Clip has no markers"), ErrorMessage);
3573         return;
3574     }
3575     QUndoCommand *deleteMarkers = new QUndoCommand();
3576     deleteMarkers->setText("Delete clip markers");
3577
3578     for (int i = 0; i < markers.size(); i++) {
3579         new AddMarkerCommand(this, markers.at(i).comment(), QString(), id, markers.at(i).time(), deleteMarkers);
3580     }
3581     m_commandStack->push(deleteMarkers);
3582 }
3583
3584 void CustomTrackView::addMarker(const QString &id, const GenTime &pos, const QString comment)
3585 {
3586     DocClipBase *base = m_document->clipManager()->getClipById(id);
3587     if (!comment.isEmpty()) base->addSnapMarker(pos, comment);
3588     else base->deleteSnapMarker(pos);
3589     setDocumentModified();
3590     viewport()->update();
3591 }
3592
3593 bool sortGuidesList(const Guide *g1 , const Guide *g2)
3594 {
3595     return (*g1).position() < (*g2).position();
3596 }
3597
3598 int CustomTrackView::hasGuide(int pos, int offset)
3599 {
3600     for (int i = 0; i < m_guides.count(); i++) {
3601         int guidePos = m_guides.at(i)->position().frames(m_document->fps());
3602         if (qAbs(guidePos - pos) <= offset) return guidePos;
3603         else if (guidePos > pos) return -1;
3604     }
3605     return -1;
3606 }
3607
3608 void CustomTrackView::editGuide(const GenTime oldPos, const GenTime pos, const QString &comment)
3609 {
3610     if (oldPos > GenTime() && pos > GenTime()) {
3611         // move guide
3612         for (int i = 0; i < m_guides.count(); i++) {
3613             if (m_guides.at(i)->position() == oldPos) {
3614                 Guide *item = m_guides.at(i);
3615                 item->updateGuide(pos, comment);
3616                 break;
3617             }
3618         }
3619     } else if (pos > GenTime()) addGuide(pos, comment);
3620     else {
3621         // remove guide
3622         bool found = false;
3623         for (int i = 0; i < m_guides.count(); i++) {
3624             if (m_guides.at(i)->position() == oldPos) {
3625                 delete m_guides.takeAt(i);
3626                 found = true;
3627                 break;
3628             }
3629         }
3630         if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
3631     }
3632     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
3633     m_document->syncGuides(m_guides);
3634 }
3635
3636 bool CustomTrackView::addGuide(const GenTime pos, const QString &comment)
3637 {
3638     for (int i = 0; i < m_guides.count(); i++) {
3639         if (m_guides.at(i)->position() == pos) {
3640             emit displayMessage(i18n("A guide already exists at position %1", m_document->timecode().getTimecodeFromFrames(pos.frames(m_document->fps()))), ErrorMessage);
3641             return false;
3642         }
3643     }
3644     Guide *g = new Guide(this, pos, comment, m_document->fps(), m_tracksHeight * m_document->tracksCount());
3645     scene()->addItem(g);
3646     m_guides.append(g);
3647     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
3648     m_document->syncGuides(m_guides);
3649     return true;
3650 }
3651
3652 void CustomTrackView::slotAddGuide()
3653 {
3654     CommentedTime marker(GenTime(m_cursorPos, m_document->fps()), i18n("Guide"));
3655     MarkerDialog d(NULL, marker, m_document->timecode(), i18n("Add Guide"), this);
3656     if (d.exec() != QDialog::Accepted) return;
3657     if (addGuide(d.newMarker().time(), d.newMarker().comment())) {
3658         EditGuideCommand *command = new EditGuideCommand(this, GenTime(), QString(), d.newMarker().time(), d.newMarker().comment(), false);
3659         m_commandStack->push(command);
3660     }
3661 }
3662
3663 void CustomTrackView::slotEditGuide(int guidePos)
3664 {
3665     GenTime pos;
3666     if (guidePos == -1) pos = GenTime(m_cursorPos, m_document->fps());
3667     else pos = GenTime(guidePos, m_document->fps());
3668     bool found = false;
3669     for (int i = 0; i < m_guides.count(); i++) {
3670         if (m_guides.at(i)->position() == pos) {
3671             slotEditGuide(m_guides.at(i)->info());
3672             found = true;
3673             break;
3674         }
3675     }
3676     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
3677 }
3678
3679 void CustomTrackView::slotEditGuide(CommentedTime guide)
3680 {
3681     MarkerDialog d(NULL, guide, m_document->timecode(), i18n("Edit Guide"), this);
3682     if (d.exec() == QDialog::Accepted) {
3683         EditGuideCommand *command = new EditGuideCommand(this, guide.time(), guide.comment(), d.newMarker().time(), d.newMarker().comment(), true);
3684         m_commandStack->push(command);
3685     }
3686 }
3687
3688
3689 void CustomTrackView::slotEditTimeLineGuide()
3690 {
3691     if (m_dragGuide == NULL) return;
3692     CommentedTime guide = m_dragGuide->info();
3693     MarkerDialog d(NULL, guide, m_document->timecode(), i18n("Edit Guide"), this);
3694     if (d.exec() == QDialog::Accepted) {
3695         EditGuideCommand *command = new EditGuideCommand(this, guide.time(), guide.comment(), d.newMarker().time(), d.newMarker().comment(), true);
3696         m_commandStack->push(command);
3697     }
3698 }
3699
3700 void CustomTrackView::slotDeleteGuide(int guidePos)
3701 {
3702     GenTime pos;
3703     if (guidePos == -1) pos = GenTime(m_cursorPos, m_document->fps());
3704     else pos = GenTime(guidePos, m_document->fps());
3705     bool found = false;
3706     for (int i = 0; i < m_guides.count(); i++) {
3707         if (m_guides.at(i)->position() == pos) {
3708             EditGuideCommand *command = new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true);
3709             m_commandStack->push(command);
3710             found = true;
3711             break;
3712         }
3713     }
3714     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
3715 }
3716
3717
3718 void CustomTrackView::slotDeleteTimeLineGuide()
3719 {
3720     if (m_dragGuide == NULL) return;
3721     EditGuideCommand *command = new EditGuideCommand(this, m_dragGuide->position(), m_dragGuide->label(), GenTime(), QString(), true);
3722     m_commandStack->push(command);
3723 }
3724
3725
3726 void CustomTrackView::slotDeleteAllGuides()
3727 {
3728     QUndoCommand *deleteAll = new QUndoCommand();
3729     deleteAll->setText("Delete all guides");
3730     for (int i = 0; i < m_guides.count(); i++) {
3731         new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true, deleteAll);
3732     }
3733     m_commandStack->push(deleteAll);
3734 }
3735
3736 void CustomTrackView::setTool(PROJECTTOOL tool)
3737 {
3738     m_tool = tool;
3739 }
3740
3741 void CustomTrackView::setScale(double scaleFactor, double verticalScale)
3742 {
3743     QMatrix matrix;
3744     matrix = matrix.scale(scaleFactor, verticalScale);
3745     m_scene->setScale(scaleFactor, verticalScale);
3746     m_animationTimer->stop();
3747     delete m_visualTip;
3748     m_visualTip = NULL;
3749     delete m_animation;
3750     m_animation = NULL;
3751     double verticalPos = mapToScene(QPoint(0, viewport()->height() / 2)).y();
3752     setMatrix(matrix);
3753     int diff = sceneRect().width() - m_projectDuration;
3754     if (diff * matrix.m11() < 50) {
3755         if (matrix.m11() < 0.4) setSceneRect(0, 0, (m_projectDuration + 100 / matrix.m11()), sceneRect().height());
3756         else setSceneRect(0, 0, (m_projectDuration + 300), sceneRect().height());
3757     }
3758     centerOn(QPointF(cursorPos(), verticalPos));
3759 }
3760
3761 void CustomTrackView::slotRefreshGuides()
3762 {
3763     if (KdenliveSettings::showmarkers()) {
3764         kDebug() << "// refresh GUIDES";
3765         for (int i = 0; i < m_guides.count(); i++) {
3766             m_guides.at(i)->update();
3767         }
3768     }
3769 }
3770
3771 void CustomTrackView::drawBackground(QPainter * painter, const QRectF &rect)
3772 {
3773     QRectF r = rect;
3774     r.setWidth(r.width() + 1);
3775     painter->setClipRect(r);
3776     painter->drawLine(r.left(), 0, r.right(), 0);
3777     uint max = m_document->tracksCount();
3778     KColorScheme scheme(palette().currentColorGroup(), KColorScheme::Window);
3779     QColor lockedColor = scheme.background(KColorScheme::NegativeBackground).color();
3780     QColor audioColor = palette().alternateBase().color();
3781     QColor base = scheme.background(KColorScheme::NormalBackground).color();
3782     for (uint i = 0; i < max; i++) {
3783         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));
3784         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));
3785         painter->drawLine(r.left(), m_tracksHeight *(i + 1), r.right(), m_tracksHeight *(i + 1));
3786     }
3787     int lowerLimit = m_tracksHeight * m_document->tracksCount() + 1;
3788     if (height() > lowerLimit)
3789         painter->fillRect(QRectF(r.left(), lowerLimit, r.width(), height() - lowerLimit), QBrush(base));
3790 }
3791
3792 bool CustomTrackView::findString(const QString &text)
3793 {
3794     QString marker;
3795     for (int i = 0; i < m_searchPoints.size(); ++i) {
3796         marker = m_searchPoints.at(i).comment();
3797         if (marker.contains(text, Qt::CaseInsensitive)) {
3798             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
3799             int vert = verticalScrollBar()->value();
3800             int hor = cursorPos();
3801             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
3802             m_findIndex = i;
3803             return true;
3804         }
3805     }
3806     return false;
3807 }
3808
3809 bool CustomTrackView::findNextString(const QString &text)
3810 {
3811     QString marker;
3812     for (int i = m_findIndex + 1; i < m_searchPoints.size(); ++i) {
3813         marker = m_searchPoints.at(i).comment();
3814         if (marker.contains(text, Qt::CaseInsensitive)) {
3815             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
3816             int vert = verticalScrollBar()->value();
3817             int hor = cursorPos();
3818             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
3819             m_findIndex = i;
3820             return true;
3821         }
3822     }
3823     m_findIndex = -1;
3824     return false;
3825 }
3826
3827 void CustomTrackView::initSearchStrings()
3828 {
3829     m_searchPoints.clear();
3830     QList<QGraphicsItem *> itemList = items();
3831     for (int i = 0; i < itemList.count(); i++) {
3832         // parse all clip names
3833         if (itemList.at(i)->type() == AVWIDGET) {
3834             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
3835             GenTime start = item->startPos();
3836             CommentedTime t(start, item->clipName());
3837             m_searchPoints.append(t);
3838             // add all clip markers
3839             QList < CommentedTime > markers = item->commentedSnapMarkers();
3840             m_searchPoints += markers;
3841         }
3842     }
3843
3844     // add guides
3845     for (int i = 0; i < m_guides.count(); i++) {
3846         m_searchPoints.append(m_guides.at(i)->info());
3847     }
3848
3849     qSort(m_searchPoints);
3850 }
3851
3852 void CustomTrackView::clearSearchStrings()
3853 {
3854     m_searchPoints.clear();
3855     m_findIndex = 0;
3856 }
3857
3858 void CustomTrackView::copyClip()
3859 {
3860     qDeleteAll(m_copiedItems);
3861     m_copiedItems.clear();
3862     QList<QGraphicsItem *> itemList = scene()->selectedItems();
3863     if (itemList.count() == 0) {
3864         emit displayMessage(i18n("Select a clip before copying"), ErrorMessage);
3865         return;
3866     }
3867     for (int i = 0; i < itemList.count(); i++) {
3868         if (itemList.at(i)->type() == AVWIDGET) {
3869             ClipItem *dup = static_cast <ClipItem *>(itemList.at(i));
3870             m_copiedItems.append(dup->clone(dup->info()));
3871         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
3872             Transition *dup = static_cast <Transition *>(itemList.at(i));
3873             m_copiedItems.append(dup->clone());
3874         }
3875     }
3876 }
3877
3878 bool CustomTrackView::canBePastedTo(ItemInfo info, int type) const
3879 {
3880     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));
3881     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
3882     for (int i = 0; i < collisions.count(); i++) {
3883         if (collisions.at(i)->type() == type) return false;
3884     }
3885     return true;
3886 }
3887
3888 bool CustomTrackView::canBePasted(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const
3889 {
3890     for (int i = 0; i < items.count(); i++) {
3891         ItemInfo info = items.at(i)->info();
3892         info.startPos += offset;
3893         info.endPos += offset;
3894         info.track += trackOffset;
3895         if (!canBePastedTo(info, items.at(i)->type())) return false;
3896     }
3897     return true;
3898 }
3899
3900 bool CustomTrackView::canBeMoved(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const
3901 {
3902     QPainterPath movePath;
3903     movePath.moveTo(0, 0);
3904
3905     for (int i = 0; i < items.count(); i++) {
3906         ItemInfo info = items.at(i)->info();
3907         info.startPos = info.startPos + offset;
3908         info.endPos = info.endPos + offset;
3909         info.track = info.track + trackOffset;
3910         if (info.startPos < GenTime()) {
3911             // No clip should go below 0
3912             return false;
3913         }
3914         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));
3915         movePath.addRect(rect);
3916     }
3917     QList<QGraphicsItem *> collisions = scene()->items(movePath, Qt::IntersectsItemBoundingRect);
3918     for (int i = 0; i < collisions.count(); i++) {
3919         if ((collisions.at(i)->type() == AVWIDGET || collisions.at(i)->type() == TRANSITIONWIDGET) && !items.contains(static_cast <AbstractClipItem *>(collisions.at(i)))) {
3920             kDebug() << "  ////////////   CLIP COLLISION, MOVE NOT ALLOWED";
3921             return false;
3922         }
3923     }
3924     return true;
3925 }
3926
3927 void CustomTrackView::pasteClip()
3928 {
3929     if (m_copiedItems.count() == 0) {
3930         emit displayMessage(i18n("No clip copied"), ErrorMessage);
3931         return;
3932     }
3933     QPoint position;
3934     if (m_menuPosition.isNull()) {
3935         position = mapFromGlobal(QCursor::pos());
3936         if (!underMouse() || position.y() > m_tracksHeight * m_document->tracksCount()) {
3937             emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
3938             return;
3939         }
3940     } else position = m_menuPosition;
3941     GenTime pos = GenTime((int)(mapToScene(position).x()), m_document->fps());
3942     int track = (int)(position.y() / m_tracksHeight);
3943     ItemInfo first = m_copiedItems.at(0)->info();
3944
3945     GenTime offset = pos - first.startPos;
3946     int trackOffset = track - first.track;
3947
3948     if (!canBePasted(m_copiedItems, offset, trackOffset)) {
3949         emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
3950         return;
3951     }
3952     QUndoCommand *pasteClips = new QUndoCommand();
3953     pasteClips->setText("Paste clips");
3954
3955     for (int i = 0; i < m_copiedItems.count(); i++) {
3956         // parse all clip names
3957         if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == AVWIDGET) {
3958             ClipItem *clip = static_cast <ClipItem *>(m_copiedItems.at(i));
3959             ItemInfo info;
3960             info.startPos = clip->startPos() + offset;
3961             info.endPos = clip->endPos() + offset;
3962             info.cropStart = clip->cropStart();
3963             info.track = clip->track() + trackOffset;
3964             if (canBePastedTo(info, AVWIDGET)) {
3965                 new AddTimelineClipCommand(this, clip->xml(), clip->clipProducer(), info, clip->effectList(), true, false, pasteClips);
3966             } else emit displayMessage(i18n("Cannot paste clip to selected place"), ErrorMessage);
3967         } else if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == TRANSITIONWIDGET) {
3968             Transition *tr = static_cast <Transition *>(m_copiedItems.at(i));
3969             ItemInfo info;
3970             info.startPos = tr->startPos() + offset;
3971             info.endPos = tr->endPos() + offset;
3972             info.track = tr->track() + trackOffset;
3973             if (canBePastedTo(info, TRANSITIONWIDGET)) {
3974                 if (info.startPos >= info.endPos) {
3975                     emit displayMessage(i18n("Invalid transition"), ErrorMessage);
3976                 } else new AddTransitionCommand(this, info, tr->transitionEndTrack() + trackOffset, tr->toXML(), false, true, pasteClips);
3977             } else emit displayMessage(i18n("Cannot paste transition to selected place"), ErrorMessage);
3978         }
3979     }
3980     m_commandStack->push(pasteClips);
3981 }
3982
3983 void CustomTrackView::pasteClipEffects()
3984 {
3985     if (m_copiedItems.count() != 1 || m_copiedItems.at(0)->type() != AVWIDGET) {
3986         emit displayMessage(i18n("You must copy exactly one clip before pasting effects"), ErrorMessage);
3987         return;
3988     }
3989     ClipItem *clip = static_cast < ClipItem *>(m_copiedItems.at(0));
3990     EffectsList effects = clip->effectList();
3991
3992     QUndoCommand *paste = new QUndoCommand();
3993     paste->setText("Paste effects");
3994
3995     QList<QGraphicsItem *> clips = scene()->selectedItems();
3996     for (int i = 0; i < clips.count(); ++i) {
3997         if (clips.at(i)->type() == AVWIDGET) {
3998             ClipItem *item = static_cast < ClipItem *>(clips.at(i));
3999             for (int i = 0; i < clip->effectsCount(); i++) {
4000                 new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), clip->effectAt(i), true, paste);
4001             }
4002         }
4003     }
4004     m_commandStack->push(paste);
4005 }
4006
4007
4008 ClipItem *CustomTrackView::getClipUnderCursor() const
4009 {
4010     QRectF rect((double) m_cursorPos, 0.0, 1.0, (double)(m_tracksHeight * m_document->tracksCount()));
4011     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
4012     for (int i = 0; i < collisions.count(); i++) {
4013         if (collisions.at(i)->type() == AVWIDGET) {
4014             return static_cast < ClipItem *>(collisions.at(i));
4015         }
4016     }
4017     return NULL;
4018 }
4019
4020 ClipItem *CustomTrackView::getMainActiveClip() const
4021 {
4022     QList<QGraphicsItem *> clips = scene()->selectedItems();
4023     if (clips.isEmpty()) {
4024         return getClipUnderCursor();
4025     } else {
4026         ClipItem *item = NULL;
4027         for (int i = 0; i < clips.count(); ++i) {
4028             if (clips.at(i)->type() == AVWIDGET)
4029                 item = static_cast < ClipItem *>(clips.at(i));
4030             if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos) break;
4031         }
4032         if (item) return item;
4033     }
4034     return NULL;
4035 }
4036
4037 ClipItem *CustomTrackView::getActiveClipUnderCursor(bool allowOutsideCursor) const
4038 {
4039     QList<QGraphicsItem *> clips = scene()->selectedItems();
4040     if (clips.isEmpty()) {
4041         return getClipUnderCursor();
4042     } else {
4043         ClipItem *item;
4044         // remove all items in the list that are not clips
4045         for (int i = 0; i < clips.count();) {
4046             if (clips.at(i)->type() != AVWIDGET) clips.removeAt(i);
4047             else i++;
4048         }
4049         if (clips.count() == 1 && allowOutsideCursor) return static_cast < ClipItem *>(clips.at(0));
4050         for (int i = 0; i < clips.count(); ++i) {
4051             if (clips.at(i)->type() == AVWIDGET) {
4052                 item = static_cast < ClipItem *>(clips.at(i));
4053                 if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos)
4054                     return item;
4055             }
4056         }
4057     }
4058     return NULL;
4059 }
4060
4061 void CustomTrackView::setInPoint()
4062 {
4063     ClipItem *clip = getActiveClipUnderCursor(true);
4064     if (clip == NULL) {
4065         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4066         return;
4067     }
4068     ItemInfo startInfo = clip->info();
4069     ItemInfo endInfo = startInfo;
4070     endInfo.startPos = GenTime(m_cursorPos, m_document->fps());
4071     if (endInfo.startPos >= startInfo.endPos) {
4072         // Check for invalid resize
4073         emit displayMessage(i18n("Invalid action"), ErrorMessage);
4074         return;
4075     } else if (endInfo.startPos < startInfo.startPos) {
4076         int length = m_document->renderer()->mltGetSpaceLength(endInfo.startPos, m_document->tracksCount() - startInfo.track, false);
4077         if (length < (startInfo.startPos - endInfo.startPos).frames(m_document->fps())) {
4078             emit displayMessage(i18n("Invalid action"), ErrorMessage);
4079             return;
4080         }
4081     }
4082     ResizeClipCommand *command = new ResizeClipCommand(this, startInfo, endInfo, true);
4083     m_commandStack->push(command);
4084 }
4085
4086 void CustomTrackView::setOutPoint()
4087 {
4088     ClipItem *clip = getActiveClipUnderCursor(true);
4089     if (clip == NULL) {
4090         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4091         return;
4092     }
4093     ItemInfo startInfo = clip->info();
4094     ItemInfo endInfo = clip->info();
4095     endInfo.endPos = GenTime(m_cursorPos, m_document->fps());
4096     if (endInfo.endPos <= startInfo.startPos) {
4097         // Check for invalid resize
4098         emit displayMessage(i18n("Invalid action"), ErrorMessage);
4099         return;
4100     } else if (endInfo.endPos > startInfo.endPos) {
4101         int length = m_document->renderer()->mltGetSpaceLength(endInfo.endPos, m_document->tracksCount() - startInfo.track, false);
4102         if (length < (endInfo.endPos - startInfo.endPos).frames(m_document->fps())) {
4103             emit displayMessage(i18n("Invalid action"), ErrorMessage);
4104             return;
4105         }
4106     }
4107
4108
4109
4110     ResizeClipCommand *command = new ResizeClipCommand(this, startInfo, endInfo, true);
4111     m_commandStack->push(command);
4112 }
4113
4114 void CustomTrackView::slotUpdateAllThumbs()
4115 {
4116     QList<QGraphicsItem *> itemList = items();
4117     //if (itemList.isEmpty()) return;
4118     ClipItem *item;
4119     const QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
4120     for (int i = 0; i < itemList.count(); i++) {
4121         if (itemList.at(i)->type() == AVWIDGET) {
4122             item = static_cast <ClipItem *>(itemList.at(i));
4123             if (item->clipType() != COLOR && item->clipType() != AUDIO) {
4124                 // Check if we have a cached thumbnail
4125                 if (item->clipType() == IMAGE || item->clipType() == TEXT) {
4126                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
4127                     if (QFile::exists(thumb)) {
4128                         QPixmap pix(thumb);
4129                         item->slotSetStartThumb(pix);
4130                     }
4131                 } else {
4132                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
4133                     QString endThumb = startThumb;
4134                     startThumb.append(QString::number(item->cropStart().frames(m_document->fps())) + ".png");
4135                     endThumb.append(QString::number((item->cropStart() + item->cropDuration()).frames(m_document->fps()) - 1) + ".png");
4136                     if (QFile::exists(startThumb)) {
4137                         QPixmap pix(startThumb);
4138                         item->slotSetStartThumb(pix);
4139                     }
4140                     if (QFile::exists(endThumb)) {
4141                         QPixmap pix(endThumb);
4142                         item->slotSetEndThumb(pix);
4143                     }
4144                 }
4145             }
4146             item->refreshClip(false);
4147             qApp->processEvents();
4148         }
4149     }
4150     viewport()->update();
4151 }
4152
4153 void CustomTrackView::saveThumbnails()
4154 {
4155     QList<QGraphicsItem *> itemList = items();
4156     ClipItem *item;
4157     QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
4158     for (int i = 0; i < itemList.count(); i++) {
4159         if (itemList.at(i)->type() == AVWIDGET) {
4160             item = static_cast <ClipItem *>(itemList.at(i));
4161             if (item->clipType() != COLOR) {
4162                 // Check if we have a cached thumbnail
4163                 if (item->clipType() == IMAGE || item->clipType() == TEXT || item->clipType() == AUDIO) {
4164                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
4165                     if (!QFile::exists(thumb)) {
4166                         QPixmap pix(item->startThumb());
4167                         pix.save(thumb);
4168                     }
4169                 } else {
4170                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
4171                     QString endThumb = startThumb;
4172                     startThumb.append(QString::number(item->cropStart().frames(m_document->fps())) + ".png");
4173                     endThumb.append(QString::number((item->cropStart() + item->cropDuration()).frames(m_document->fps()) - 1) + ".png");
4174                     if (!QFile::exists(startThumb)) {
4175                         QPixmap pix(item->startThumb());
4176                         pix.save(startThumb);
4177                     }
4178                     if (!QFile::exists(endThumb)) {
4179                         QPixmap pix(item->endThumb());
4180                         pix.save(endThumb);
4181                     }
4182                 }
4183             }
4184         }
4185     }
4186 }
4187
4188
4189 void CustomTrackView::slotInsertTrack(int ix)
4190 {
4191     kDebug() << "// INSERTING TRK: " << ix;
4192     QDialog d(parentWidget());
4193     Ui::AddTrack_UI view;
4194     view.setupUi(&d);
4195     view.track_nb->setMaximum(m_document->tracksCount() - 1);
4196     view.track_nb->setValue(ix);
4197     d.setWindowTitle(i18n("Insert Track"));
4198
4199     if (d.exec() == QDialog::Accepted) {
4200         ix = view.track_nb->value();
4201         if (view.before_select->currentIndex() == 1) {
4202             ix++;
4203         }
4204         TrackInfo info;
4205         if (view.video_track->isChecked()) {
4206             info.type = VIDEOTRACK;
4207             info.isMute = false;
4208             info.isBlind = false;
4209             info.isLocked = false;
4210         } else {
4211             info.type = AUDIOTRACK;
4212             info.isMute = false;
4213             info.isBlind = true;
4214             info.isLocked = false;
4215         }
4216         AddTrackCommand *addTrack = new AddTrackCommand(this, ix, info, true);
4217         m_commandStack->push(addTrack);
4218         setDocumentModified();
4219     }
4220 }
4221
4222 void CustomTrackView::slotDeleteTrack(int ix)
4223 {
4224     bool ok;
4225     ix = QInputDialog::getInteger(this, i18n("Remove Track"), i18n("Track"), ix, 0, m_document->tracksCount() - 1, 1, &ok);
4226     if (ok) {
4227         TrackInfo info = m_document->trackInfoAt(m_document->tracksCount() - ix - 1);
4228         deleteTimelineTrack(ix, info);
4229         setDocumentModified();
4230         /*AddTrackCommand* command = new AddTrackCommand(this, ix, info, false);
4231         m_commandStack->push(command);*/
4232     }
4233 }
4234
4235 void CustomTrackView::slotChangeTrack(int ix)
4236 {
4237     QDialog d(parentWidget());
4238     Ui::AddTrack_UI view;
4239     view.setupUi(&d);
4240     view.label->setText(i18n("Change track"));
4241     view.before_select->setHidden(true);
4242     view.track_nb->setMaximum(m_document->tracksCount() - 1);
4243     view.track_nb->setValue(ix);
4244     d.setWindowTitle(i18n("Change Track Type"));
4245
4246     if (m_document->trackInfoAt(m_document->tracksCount() - ix - 1).type == VIDEOTRACK)
4247         view.video_track->setChecked(true);
4248     else
4249         view.audio_track->setChecked(true);
4250
4251     if (d.exec() == QDialog::Accepted) {
4252         TrackInfo info;
4253         info.isLocked = false;
4254         info.isMute = false;
4255         ix = view.track_nb->value();
4256
4257         if (view.video_track->isChecked()) {
4258             info.type = VIDEOTRACK;
4259             info.isBlind = false;
4260         } else {
4261             info.type = AUDIOTRACK;
4262             info.isBlind = true;
4263         }
4264         changeTimelineTrack(ix, info);
4265         setDocumentModified();
4266     }
4267 }
4268
4269
4270 void CustomTrackView::deleteTimelineTrack(int ix, TrackInfo trackinfo)
4271 {
4272     double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
4273     QRectF r(0, startY, sceneRect().width(), m_tracksHeight / 2 - 1);
4274     QList<QGraphicsItem *> selection = m_scene->items(r);
4275     QUndoCommand *deleteTrack = new QUndoCommand();
4276     deleteTrack->setText("Delete track");
4277
4278     // Delete all clips in selected track
4279     for (int i = 0; i < selection.count(); i++) {
4280         if (selection.at(i)->type() == AVWIDGET) {
4281             ClipItem *item =  static_cast <ClipItem *>(selection.at(i));
4282             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, true, deleteTrack);
4283             m_scene->removeItem(item);
4284             delete item;
4285             item = NULL;
4286         } else if (selection.at(i)->type() == TRANSITIONWIDGET) {
4287             Transition *item =  static_cast <Transition *>(selection.at(i));
4288             new AddTransitionCommand(this, item->info(), item->transitionEndTrack(), item->toXML(), true, false, deleteTrack);
4289             m_scene->removeItem(item);
4290             delete item;
4291             item = NULL;
4292         }
4293     }
4294
4295     selection = m_scene->items();
4296     new AddTrackCommand(this, ix, trackinfo, false, deleteTrack);
4297     m_commandStack->push(deleteTrack);
4298 }
4299
4300 void CustomTrackView::changeTimelineTrack(int ix, TrackInfo trackinfo)
4301 {
4302     TrackInfo oldinfo = m_document->trackInfoAt(m_document->tracksCount() - ix - 1);
4303     ChangeTrackCommand *changeTrack = new ChangeTrackCommand(this, ix, oldinfo, trackinfo);
4304     m_commandStack->push(changeTrack);
4305 }
4306
4307 void CustomTrackView::autoTransition()
4308 {
4309     QList<QGraphicsItem *> itemList = scene()->selectedItems();
4310     if (itemList.count() != 1 || itemList.at(0)->type() != TRANSITIONWIDGET) {
4311         emit displayMessage(i18n("You must select one transition for this action"), ErrorMessage);
4312         return;
4313     }
4314     Transition *tr = static_cast <Transition*>(itemList.at(0));
4315     tr->setAutomatic(!tr->isAutomatic());
4316     QDomElement transition = tr->toXML();
4317     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);
4318 }
4319
4320
4321 QStringList CustomTrackView::getLadspaParams(QDomElement effect) const
4322 {
4323     QStringList result;
4324     QDomNodeList params = effect.elementsByTagName("parameter");
4325     for (int i = 0; i < params.count(); i++) {
4326         QDomElement e = params.item(i).toElement();
4327         if (!e.isNull() && e.attribute("type") == "constant") {
4328             if (e.hasAttribute("factor")) {
4329                 double factor = e.attribute("factor").toDouble();
4330                 double value = e.attribute("value").toDouble();
4331                 value = value / factor;
4332                 result.append(QString::number(value));
4333             } else result.append(e.attribute("value"));
4334         }
4335     }
4336     return result;
4337 }
4338
4339 void CustomTrackView::clipNameChanged(const QString id, const QString name)
4340 {
4341     QList<QGraphicsItem *> list = scene()->items();
4342     ClipItem *clip = NULL;
4343     for (int i = 0; i < list.size(); ++i) {
4344         if (list.at(i)->type() == AVWIDGET) {
4345             clip = static_cast <ClipItem *>(list.at(i));
4346             if (clip->clipProducer() == id) {
4347                 clip->setClipName(name);
4348             }
4349         }
4350     }
4351     viewport()->update();
4352 }
4353
4354 void CustomTrackView::getClipAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum)
4355 {
4356     minimum = GenTime();
4357     maximum = GenTime();
4358     QList<QGraphicsItem *> selection;
4359     selection = m_scene->items(0, item->track() * m_tracksHeight + m_tracksHeight / 2, sceneRect().width(), 2);
4360     selection.removeAll(item);
4361     for (int i = 0; i < selection.count(); i++) {
4362         AbstractClipItem *clip = static_cast <AbstractClipItem *>(selection.at(i));
4363         if (clip && clip->type() == AVWIDGET) {
4364             if (clip->endPos() <= item->startPos() && clip->endPos() > minimum) minimum = clip->endPos();
4365             if (clip->startPos() > item->startPos() && (clip->startPos() < maximum || maximum == GenTime())) maximum = clip->startPos();
4366         }
4367     }
4368 }
4369
4370 void CustomTrackView::getTransitionAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum)
4371 {
4372     minimum = GenTime();
4373     maximum = GenTime();
4374     QList<QGraphicsItem *> selection;
4375     selection = m_scene->items(0, (item->track() + 1) * m_tracksHeight, sceneRect().width(), 2);
4376     selection.removeAll(item);
4377     for (int i = 0; i < selection.count(); i++) {
4378         AbstractClipItem *clip = static_cast <AbstractClipItem *>(selection.at(i));
4379         if (clip && clip->type() == TRANSITIONWIDGET) {
4380             if (clip->endPos() <= item->startPos() && clip->endPos() > minimum) minimum = clip->endPos();
4381             if (clip->startPos() > item->startPos() && (clip->startPos() < maximum || maximum == GenTime())) maximum = clip->startPos();
4382         }
4383     }
4384 }
4385
4386
4387 void CustomTrackView::loadGroups(const QDomNodeList groups)
4388 {
4389     for (int i = 0; i < groups.count(); i++) {
4390         QDomNodeList children = groups.at(i).childNodes();
4391         scene()->clearSelection();
4392         for (int nodeindex = 0; nodeindex < children.count(); nodeindex++) {
4393             QDomNode n = children.item(nodeindex);
4394             QDomElement elem = n.toElement();
4395             int pos = elem.attribute("position").toInt();
4396             int track = elem.attribute("track").toInt();
4397             if (elem.tagName() == "clipitem") {
4398                 ClipItem *clip = getClipItemAt(pos, track); //m_document->tracksCount() - transitiontrack);
4399                 if (clip) clip->setSelected(true);
4400             } else {
4401                 Transition *clip = getTransitionItemAt(pos, track); //m_document->tracksCount() - transitiontrack);
4402                 if (clip) clip->setSelected(true);
4403             }
4404         }
4405         groupSelectedItems(false, true);
4406     }
4407 }
4408
4409 void CustomTrackView::splitAudio()
4410 {
4411     resetSelectionGroup();
4412     QList<QGraphicsItem *> selection = scene()->selectedItems();
4413     if (selection.isEmpty()) {
4414         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4415         return;
4416     }
4417     QUndoCommand *splitCommand = new QUndoCommand();
4418     splitCommand->setText(i18n("Split audio"));
4419     for (int i = 0; i < selection.count(); i++) {
4420         if (selection.at(i)->type() == AVWIDGET) {
4421             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
4422             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
4423                 if (clip->parentItem()) {
4424                     emit displayMessage(i18n("Cannot split audio of grouped clips"), ErrorMessage);
4425                 } else {
4426                     new SplitAudioCommand(this, clip->track(), clip->startPos(), splitCommand);
4427                 }
4428             }
4429         }
4430     }
4431     m_commandStack->push(splitCommand);
4432 }
4433
4434 void CustomTrackView::doSplitAudio(const GenTime &pos, int track, bool split)
4435 {
4436     ClipItem *clip = getClipItemAt(pos, track);
4437     if (clip == NULL) {
4438         kDebug() << "// Cannot find clip to split!!!";
4439         return;
4440     }
4441     if (split) {
4442         int start = pos.frames(m_document->fps());
4443         int freetrack = m_document->tracksCount() - track - 1;
4444         for (; freetrack > 0; freetrack--) {
4445             kDebug() << "// CHK DOC TRK:" << freetrack << ", DUR:" << m_document->renderer()->mltTrackDuration(freetrack);
4446             if (m_document->trackInfoAt(freetrack - 1).type == AUDIOTRACK) {
4447                 kDebug() << "// CHK DOC TRK:" << freetrack << ", DUR:" << m_document->renderer()->mltTrackDuration(freetrack);
4448                 if (m_document->renderer()->mltTrackDuration(freetrack) < start || m_document->renderer()->mltGetSpaceLength(pos, freetrack, false) >= clip->cropDuration().frames(m_document->fps())) {
4449                     kDebug() << "FOUND SPACE ON TRK: " << freetrack;
4450                     break;
4451                 }
4452             }
4453         }
4454         kDebug() << "GOT TRK: " << track;
4455         if (freetrack == 0) {
4456             emit displayMessage(i18n("No empty space to put clip audio"), ErrorMessage);
4457         } else {
4458             ItemInfo info;
4459             info.startPos = clip->startPos();
4460             info.endPos = clip->endPos();
4461             info.cropStart = clip->cropStart();
4462             info.track = m_document->tracksCount() - freetrack;
4463             addClip(clip->xml(), clip->clipProducer(), info, clip->effectList());
4464             scene()->clearSelection();
4465             clip->setSelected(true);
4466             ClipItem *audioClip = getClipItemAt(start, info.track);
4467             if (audioClip) {
4468                 clip->setVideoOnly(true);
4469                 m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - track, start, clip->baseClip()->videoProducer());
4470                 m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - info.track, start, clip->baseClip()->audioProducer(info.track));
4471                 audioClip->setSelected(true);
4472                 audioClip->setAudioOnly(true);
4473                 groupSelectedItems(false, true);
4474             }
4475         }
4476     } else {
4477         // unsplit clip: remove audio part and change video part to normal clip
4478         if (clip->parentItem() == NULL || clip->parentItem()->type() != GROUPWIDGET) {
4479             kDebug() << "//CANNOT FIND CLP GRP";
4480             return;
4481         }
4482         AbstractGroupItem *grp = static_cast <AbstractGroupItem *>(clip->parentItem());
4483         QList<QGraphicsItem *> children = grp->childItems();
4484         if (children.count() != 2) {
4485             kDebug() << "//SOMETHING IS WRONG WITH CLP GRP";
4486             return;
4487         }
4488         for (int i = 0; i < children.count(); i++) {
4489             if (children.at(i) != clip) {
4490                 ClipItem *clp = static_cast <ClipItem *>(children.at(i));
4491                 ItemInfo info = clip->info();
4492                 deleteClip(clp->info());
4493                 clip->setVideoOnly(false);
4494                 m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - info.track, info.startPos.frames(m_document->fps()), clip->baseClip()->producer(info.track));
4495                 break;
4496             }
4497         }
4498         clip->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
4499         m_document->clipManager()->removeGroup(grp);
4500         scene()->destroyItemGroup(grp);
4501     }
4502 }
4503
4504 void CustomTrackView::setVideoOnly()
4505 {
4506     resetSelectionGroup();
4507     QList<QGraphicsItem *> selection = scene()->selectedItems();
4508     if (selection.isEmpty()) {
4509         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4510         return;
4511     }
4512     QUndoCommand *videoCommand = new QUndoCommand();
4513     videoCommand->setText(i18n("Video only"));
4514     for (int i = 0; i < selection.count(); i++) {
4515         if (selection.at(i)->type() == AVWIDGET) {
4516             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
4517             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
4518                 if (clip->parentItem()) {
4519                     emit displayMessage(i18n("Cannot change grouped clips"), ErrorMessage);
4520                 } else {
4521                     new ChangeClipTypeCommand(this, clip->track(), clip->startPos(), true, false, clip->isVideoOnly(), clip->isAudioOnly(), videoCommand);
4522                 }
4523             }
4524         }
4525     }
4526     m_commandStack->push(videoCommand);
4527 }
4528
4529 void CustomTrackView::setAudioOnly()
4530 {
4531     resetSelectionGroup();
4532     QList<QGraphicsItem *> selection = scene()->selectedItems();
4533     if (selection.isEmpty()) {
4534         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4535         return;
4536     }
4537     QUndoCommand *videoCommand = new QUndoCommand();
4538     videoCommand->setText(i18n("Audio only"));
4539     for (int i = 0; i < selection.count(); i++) {
4540         if (selection.at(i)->type() == AVWIDGET) {
4541             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
4542             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
4543                 if (clip->parentItem()) {
4544                     emit displayMessage(i18n("Cannot change grouped clips"), ErrorMessage);
4545                 } else {
4546                     new ChangeClipTypeCommand(this, clip->track(), clip->startPos(), false, true, clip->isVideoOnly(), clip->isAudioOnly(), videoCommand);
4547                 }
4548             }
4549         }
4550     }
4551     m_commandStack->push(videoCommand);
4552 }
4553
4554 void CustomTrackView::setAudioAndVideo()
4555 {
4556     resetSelectionGroup();
4557     QList<QGraphicsItem *> selection = scene()->selectedItems();
4558     if (selection.isEmpty()) {
4559         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4560         return;
4561     }
4562     QUndoCommand *videoCommand = new QUndoCommand();
4563     videoCommand->setText(i18n("Audio and Video"));
4564     for (int i = 0; i < selection.count(); i++) {
4565         if (selection.at(i)->type() == AVWIDGET) {
4566             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
4567             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
4568                 if (clip->parentItem()) {
4569                     emit displayMessage(i18n("Cannot change grouped clips"), ErrorMessage);
4570                 } else {
4571                     new ChangeClipTypeCommand(this, clip->track(), clip->startPos(), false, false, clip->isVideoOnly(), clip->isAudioOnly(), videoCommand);
4572                 }
4573             }
4574         }
4575     }
4576     m_commandStack->push(videoCommand);
4577 }
4578
4579 void CustomTrackView::doChangeClipType(const GenTime &pos, int track, bool videoOnly, bool audioOnly)
4580 {
4581     ClipItem *clip = getClipItemAt(pos, track);
4582     if (clip == NULL) {
4583         kDebug() << "// Cannot find clip to split!!!";
4584         return;
4585     }
4586     if (videoOnly) {
4587         int start = pos.frames(m_document->fps());
4588         clip->setVideoOnly(true);
4589         clip->setAudioOnly(false);
4590         m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - track, start, clip->baseClip()->videoProducer());
4591     } else if (audioOnly) {
4592         int start = pos.frames(m_document->fps());
4593         clip->setAudioOnly(true);
4594         clip->setVideoOnly(false);
4595         m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - track, start, clip->baseClip()->audioProducer(track));
4596     } else {
4597         int start = pos.frames(m_document->fps());
4598         clip->setAudioOnly(false);
4599         clip->setVideoOnly(false);
4600         m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - track, start, clip->baseClip()->producer(track));
4601     }
4602     clip->update();
4603     setDocumentModified();
4604 }
4605
4606 void CustomTrackView::updateClipTypeActions(ClipItem *clip)
4607 {
4608     if (clip == NULL || (clip->clipType() != AV && clip->clipType() != PLAYLIST)) {
4609         m_clipTypeGroup->setEnabled(false);
4610     } else {
4611         m_clipTypeGroup->setEnabled(true);
4612         QList <QAction *> actions = m_clipTypeGroup->actions();
4613         QString lookup;
4614         if (clip->isAudioOnly()) lookup = "clip_audio_only";
4615         else if (clip->isVideoOnly()) lookup = "clip_video_only";
4616         else  lookup = "clip_audio_and_video";
4617         for (int i = 0; i < actions.count(); i++) {
4618             if (actions.at(i)->data().toString() == lookup) {
4619                 actions.at(i)->setChecked(true);
4620                 break;
4621             }
4622         }
4623     }
4624 }
4625
4626 void CustomTrackView::reloadTransitionLumas()
4627 {
4628     QString lumaNames;
4629     QString lumaFiles;
4630     QDomElement lumaTransition = MainWindow::transitions.getEffectByTag("luma", "luma");
4631     QDomNodeList params = lumaTransition.elementsByTagName("parameter");
4632     for (int i = 0; i < params.count(); i++) {
4633         QDomElement e = params.item(i).toElement();
4634         if (e.attribute("tag") == "resource") {
4635             lumaNames = e.attribute("paramlistdisplay");
4636             lumaFiles = e.attribute("paramlist");
4637             break;
4638         }
4639     }
4640
4641     QList<QGraphicsItem *> itemList = items();
4642     Transition *transitionitem;
4643     QDomElement transitionXml;
4644     for (int i = 0; i < itemList.count(); i++) {
4645         if (itemList.at(i)->type() == TRANSITIONWIDGET) {
4646             transitionitem = static_cast <Transition*>(itemList.at(i));
4647             transitionXml = transitionitem->toXML();
4648             if (transitionXml.attribute("id") == "luma" && transitionXml.attribute("tag") == "luma") {
4649                 QDomNodeList params = transitionXml.elementsByTagName("parameter");
4650                 for (int i = 0; i < params.count(); i++) {
4651                     QDomElement e = params.item(i).toElement();
4652                     if (e.attribute("tag") == "resource") {
4653                         e.setAttribute("paramlistdisplay", lumaNames);
4654                         e.setAttribute("paramlist", lumaFiles);
4655                         break;
4656                     }
4657                 }
4658             }
4659             if (transitionXml.attribute("id") == "composite" && transitionXml.attribute("tag") == "composite") {
4660                 QDomNodeList params = transitionXml.elementsByTagName("parameter");
4661                 for (int i = 0; i < params.count(); i++) {
4662                     QDomElement e = params.item(i).toElement();
4663                     if (e.attribute("tag") == "luma") {
4664                         e.setAttribute("paramlistdisplay", lumaNames);
4665                         e.setAttribute("paramlist", lumaFiles);
4666                         break;
4667                     }
4668                 }
4669             }
4670         }
4671     }
4672     emit transitionItemSelected(NULL);
4673 }
4674
4675 #include "customtrackview.moc"