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