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