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 #include <KMessageBox>
  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
1915 #if QT_VERSION >= 0x040600
1916     // animate item deletion
1917     item->closeAnimation();
1918 #else
1919     delete item;
1920 #endif
1921     emit transitionItemSelected(NULL);
1922     setDocumentModified();
1923 }
1924
1925 void CustomTrackView::slotTransitionUpdated(Transition *tr, QDomElement old)
1926 {
1927     //kDebug() << "TRANS UPDATE, TRACKS: " << old.attribute("transition_btrack") << ", NEW: " << tr->toXML().attribute("transition_btrack");
1928     EditTransitionCommand *command = new EditTransitionCommand(this, tr->track(), tr->startPos(), old, tr->toXML(), false);
1929     m_commandStack->push(command);
1930     setDocumentModified();
1931 }
1932
1933 void CustomTrackView::updateTransition(int track, GenTime pos, QDomElement oldTransition, QDomElement transition, bool updateTransitionWidget)
1934 {
1935     Transition *item = getTransitionItemAt(pos, track);
1936     if (!item) {
1937         kWarning() << "Unable to find transition at pos :" << pos.frames(m_document->fps()) << ", ON track: " << track;
1938         return;
1939     }
1940     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);
1941     //kDebug() << "ORIGINAL TRACK: "<< oldTransition.attribute("transition_btrack") << ", NEW TRACK: "<<transition.attribute("transition_btrack");
1942     item->setTransitionParameters(transition);
1943     if (updateTransitionWidget) {
1944         ItemInfo info = item->info();
1945         QPoint p;
1946         ClipItem *transitionClip = getClipItemAt(info.startPos, info.track);
1947         if (transitionClip && transitionClip->baseClip()) {
1948             QString size = transitionClip->baseClip()->getProperty("frame_size");
1949             double factor = transitionClip->baseClip()->getProperty("aspect_ratio").toDouble();
1950             p.setX((int)(size.section('x', 0, 0).toInt() * factor + 0.5));
1951             p.setY(size.section('x', 1, 1).toInt());
1952         }
1953         emit transitionItemSelected(item, getPreviousVideoTrack(info.track), p, true);
1954     }
1955     setDocumentModified();
1956 }
1957
1958 void CustomTrackView::dragMoveEvent(QDragMoveEvent * event)
1959 {
1960     if (m_clipDrag) {
1961         const QPointF pos = mapToScene(event->pos());
1962         if (m_selectionGroup) {
1963             m_selectionGroup->setPos(pos);
1964             emit mousePosition((int)(m_selectionGroup->scenePos().x() + 0.5));
1965             event->acceptProposedAction();
1966         } else {
1967             // Drag enter was not possible, try again at mouse position
1968             insertDropClips(event->mimeData(), event->pos());
1969             event->accept();
1970         }
1971     } else {
1972         QGraphicsView::dragMoveEvent(event);
1973     }
1974 }
1975
1976 void CustomTrackView::dragLeaveEvent(QDragLeaveEvent * event)
1977 {
1978     if (m_selectionGroup && m_clipDrag) {
1979         m_thumbsTimer.stop();
1980         m_waitingThumbs.clear();
1981         QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1982         qDeleteAll(items);
1983         scene()->destroyItemGroup(m_selectionGroup);
1984         m_selectionGroup = NULL;
1985     } else QGraphicsView::dragLeaveEvent(event);
1986 }
1987
1988 void CustomTrackView::dropEvent(QDropEvent * event)
1989 {
1990     if (m_selectionGroup && m_clipDrag) {
1991         QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1992         resetSelectionGroup();
1993         m_scene->clearSelection();
1994         bool hasVideoClip = false;
1995         QUndoCommand *addCommand = new QUndoCommand();
1996         addCommand->setText(i18n("Add timeline clip"));
1997
1998         for (int i = 0; i < items.count(); i++) {
1999             ClipItem *item = static_cast <ClipItem *>(items.at(i));
2000             if (!hasVideoClip && (item->clipType() == AV || item->clipType() == VIDEO)) hasVideoClip = true;
2001             if (items.count() == 1) {
2002                 updateClipTypeActions(item);
2003             } else {
2004                 updateClipTypeActions(NULL);
2005             }
2006
2007             //TODO: take care of edit mode for undo
2008             item->baseClip()->addReference();
2009             item->setZValue(item->defaultZValue());
2010             m_document->updateClip(item->baseClip()->getId());
2011             ItemInfo info = item->info();
2012
2013             int tracknumber = m_document->tracksCount() - info.track - 1;
2014             bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2015             if (isLocked) item->setItemLocked(true);
2016             ItemInfo clipInfo = info;
2017             clipInfo.track = m_document->tracksCount() - item->track();
2018             if (m_document->renderer()->mltInsertClip(clipInfo, item->xml(), item->baseClip()->producer(item->track()), m_scene->editMode() == OVERWRITEEDIT, m_scene->editMode() == INSERTEDIT) == -1) {
2019                 emit displayMessage(i18n("Cannot insert clip in timeline"), ErrorMessage);
2020             }
2021             adjustTimelineClips(m_scene->editMode(), item, addCommand);
2022
2023             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, false, addCommand);
2024
2025             if (item->baseClip()->isTransparent() && getTransitionItemAtStart(info.startPos, info.track) == NULL) {
2026                 // add transparency transition
2027                 QDomElement trans = MainWindow::transitions.getEffectByTag("composite", "composite").cloneNode().toElement();
2028                 new AddTransitionCommand(this, info, getPreviousVideoTrack(info.track), trans, false, true, addCommand);
2029             }
2030             item->setSelected(true);
2031         }
2032         m_commandStack->push(addCommand);
2033         setDocumentModified();
2034         m_pasteEffectsAction->setEnabled(m_copiedItems.count() == 1);
2035         if (items.count() > 1) groupSelectedItems(true);
2036         event->setDropAction(Qt::MoveAction);
2037         event->accept();
2038     } else QGraphicsView::dropEvent(event);
2039     setFocus();
2040 }
2041
2042 void CustomTrackView::adjustTimelineClips(EDITMODE mode, ClipItem *item, QUndoCommand *command)
2043 {
2044     if (mode == OVERWRITEEDIT) {
2045         // if we are in overwrite or push mode, move clips accordingly
2046         bool snap = KdenliveSettings::snaptopoints();
2047         KdenliveSettings::setSnaptopoints(false);
2048         ItemInfo info = item->info();
2049         QRectF rect(info.startPos.frames(m_document->fps()), info.track * m_tracksHeight + m_tracksHeight / 2, (info.endPos - info.startPos).frames(m_document->fps()) - 1, 5);
2050         QList<QGraphicsItem *> selection = m_scene->items(rect);
2051         selection.removeAll(item);
2052         for (int i = 0; i < selection.count(); i++) {
2053             if (selection.at(i)->type() == AVWIDGET) {
2054                 ClipItem *clip = static_cast<ClipItem *>(selection.at(i));
2055                 if (clip->startPos() < info.startPos) {
2056                     if (clip->endPos() > info.endPos) {
2057                         ItemInfo clipInfo = clip->info();
2058                         ItemInfo dupInfo = clipInfo;
2059                         GenTime diff = info.startPos - clip->startPos();
2060                         dupInfo.startPos = info.startPos;
2061                         dupInfo.cropStart += diff;
2062                         dupInfo.cropDuration = clipInfo.endPos - info.startPos;
2063                         ItemInfo newdupInfo = dupInfo;
2064                         GenTime diff2 = info.endPos - info.startPos;
2065                         newdupInfo.startPos = info.endPos;
2066                         newdupInfo.cropStart += diff2;
2067                         newdupInfo.cropDuration = clipInfo.endPos - info.endPos;
2068                         new RazorClipCommand(this, clipInfo, info.startPos, false, command);
2069                         new ResizeClipCommand(this, dupInfo, newdupInfo, false, false, command);
2070                         ClipItem *dup = cutClip(clipInfo, info.startPos, true, false);
2071                         if (dup) dup->resizeStart(info.endPos.frames(m_document->fps()));
2072
2073                     } else {
2074                         ItemInfo newclipInfo = clip->info();
2075                         newclipInfo.endPos = info.startPos;
2076                         new ResizeClipCommand(this, clip->info(), newclipInfo, false, false, command);
2077                         clip->resizeEnd(info.startPos.frames(m_document->fps()));
2078                     }
2079                 } else if (clip->endPos() < info.endPos) {
2080                     new AddTimelineClipCommand(this, clip->xml(), clip->clipProducer(), clip->info(), clip->effectList(), false, true, command);
2081                     scene()->removeItem(clip);
2082                     delete clip;
2083                     clip = NULL;
2084                 } else {
2085                     ItemInfo newclipInfo = clip->info();
2086                     newclipInfo.startPos = info.endPos;
2087                     new ResizeClipCommand(this, clip->info(), newclipInfo, false, false, command);
2088                     clip->resizeStart(info.endPos.frames(m_document->fps()));
2089                 }
2090             }
2091         }
2092         KdenliveSettings::setSnaptopoints(snap);
2093     }
2094 }
2095
2096
2097 void CustomTrackView::adjustTimelineTransitions(EDITMODE mode, Transition *item, QUndoCommand *command)
2098 {
2099     if (mode == OVERWRITEEDIT) {
2100         // if we are in overwrite or push mode, move clips accordingly
2101         bool snap = KdenliveSettings::snaptopoints();
2102         KdenliveSettings::setSnaptopoints(false);
2103         ItemInfo info = item->info();
2104         QRectF rect(info.startPos.frames(m_document->fps()), info.track * m_tracksHeight + m_tracksHeight, (info.endPos - info.startPos).frames(m_document->fps()) - 1, 5);
2105         QList<QGraphicsItem *> selection = m_scene->items(rect);
2106         selection.removeAll(item);
2107         for (int i = 0; i < selection.count(); i++) {
2108             if (selection.at(i)->type() == TRANSITIONWIDGET) {
2109                 Transition *tr = static_cast<Transition *>(selection.at(i));
2110                 if (tr->startPos() < info.startPos) {
2111                     ItemInfo firstPos = tr->info();
2112                     ItemInfo newPos = firstPos;
2113                     firstPos.endPos = item->startPos();
2114                     newPos.startPos = item->endPos();
2115                     new MoveTransitionCommand(this, tr->info(), firstPos, true, command);
2116                     if (tr->endPos() > info.endPos) {
2117                         // clone transition
2118                         new AddTransitionCommand(this, newPos, tr->transitionEndTrack(), tr->toXML(), false, true, command);
2119                     }
2120                 } else if (tr->endPos() > info.endPos) {
2121                     // just resize
2122                     ItemInfo firstPos = tr->info();
2123                     firstPos.startPos = item->endPos();
2124                     new MoveTransitionCommand(this, tr->info(), firstPos, true, command);
2125                 } else {
2126                     // remove transition
2127                     new AddTransitionCommand(this, tr->info(), tr->transitionEndTrack(), tr->toXML(), true, true, command);
2128                 }
2129             }
2130         }
2131         KdenliveSettings::setSnaptopoints(snap);
2132     }
2133 }
2134
2135 QStringList CustomTrackView::mimeTypes() const
2136 {
2137     QStringList qstrList;
2138     // list of accepted mime types for drop
2139     qstrList.append("text/plain");
2140     qstrList.append("kdenlive/producerslist");
2141     qstrList.append("kdenlive/clip");
2142     return qstrList;
2143 }
2144
2145 Qt::DropActions CustomTrackView::supportedDropActions() const
2146 {
2147     // returns what actions are supported when dropping
2148     return Qt::MoveAction;
2149 }
2150
2151 void CustomTrackView::setDuration(int duration)
2152 {
2153     int diff = qAbs(duration - sceneRect().width());
2154     if (diff * matrix().m11() > -50) {
2155         if (matrix().m11() < 0.4) setSceneRect(0, 0, (duration + 100 / matrix().m11()), sceneRect().height());
2156         else setSceneRect(0, 0, (duration + 300), sceneRect().height());
2157     }
2158     m_projectDuration = duration;
2159 }
2160
2161 int CustomTrackView::duration() const
2162 {
2163     return m_projectDuration;
2164 }
2165
2166 void CustomTrackView::addTrack(TrackInfo type, int ix)
2167 {
2168     if (ix == -1 || ix == m_document->tracksCount()) {
2169         m_document->insertTrack(ix, type);
2170         m_document->renderer()->mltInsertTrack(1, type.type == VIDEOTRACK);
2171     } else {
2172         m_document->insertTrack(m_document->tracksCount() - ix, type);
2173         // insert track in MLT playlist
2174         m_document->renderer()->mltInsertTrack(m_document->tracksCount() - ix, type.type == VIDEOTRACK);
2175
2176         double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
2177         QRectF r(0, startY, sceneRect().width(), sceneRect().height() - startY);
2178         QList<QGraphicsItem *> selection = m_scene->items(r);
2179         resetSelectionGroup();
2180
2181         m_selectionGroup = new AbstractGroupItem(m_document->fps());
2182         scene()->addItem(m_selectionGroup);
2183         for (int i = 0; i < selection.count(); i++) {
2184             if ((!selection.at(i)->parentItem()) && (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET || selection.at(i)->type() == GROUPWIDGET)) {
2185                 m_selectionGroup->addToGroup(selection.at(i));
2186                 selection.at(i)->setFlag(QGraphicsItem::ItemIsMovable, false);
2187             }
2188         }
2189         // Move graphic items
2190         m_selectionGroup->translate(0, m_tracksHeight);
2191
2192         // adjust track number
2193         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
2194         for (int i = 0; i < children.count(); i++) {
2195             if (children.at(i)->type() == GROUPWIDGET) {
2196                 AbstractGroupItem *grp = static_cast<AbstractGroupItem*>(children.at(i));
2197                 children << grp->childItems();
2198                 continue;
2199             }
2200             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
2201             item->updateItem();
2202             ItemInfo clipinfo = item->info();
2203             if (item->type() == AVWIDGET) {
2204                 ClipItem *clip = static_cast <ClipItem *>(item);
2205                 // We add a move clip command so that we get the correct producer for new track number
2206                 if (clip->clipType() == AV || clip->clipType() == AUDIO) {
2207                     Mlt::Producer *prod;
2208                     if (clip->isAudioOnly()) prod = clip->baseClip()->audioProducer(clipinfo.track);
2209                     else if (clip->isVideoOnly()) prod = clip->baseClip()->videoProducer();
2210                     else prod = clip->baseClip()->producer(clipinfo.track);
2211                     if (m_document->renderer()->mltUpdateClipProducer((int)(m_document->tracksCount() - clipinfo.track), clipinfo.startPos.frames(m_document->fps()), prod) == false) {
2212                         // problem updating clip
2213                         emit displayMessage(i18n("Cannot update clip (time: %1, track: %2)", clipinfo.startPos.frames(m_document->fps()), clipinfo.track), ErrorMessage);
2214                     }
2215                 }
2216             } else if (item->type() == TRANSITIONWIDGET) {
2217                 Transition *tr = static_cast <Transition *>(item);
2218                 int track = tr->transitionEndTrack();
2219                 if (track >= ix) {
2220                     tr->updateTransitionEndTrack(getPreviousVideoTrack(clipinfo.track));
2221                 }
2222             }
2223         }
2224         resetSelectionGroup(false);
2225     }
2226
2227     int maxHeight = m_tracksHeight * m_document->tracksCount();
2228     for (int i = 0; i < m_guides.count(); i++) {
2229         QLineF l = m_guides.at(i)->line();
2230         l.setP2(QPointF(l.x2(), maxHeight));
2231         m_guides.at(i)->setLine(l);
2232     }
2233     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), maxHeight);
2234     setSceneRect(0, 0, sceneRect().width(), maxHeight);
2235     viewport()->update();
2236     emit tracksChanged();
2237     //QTimer::singleShot(500, this, SIGNAL(trackHeightChanged()));
2238     //setFixedHeight(50 * m_tracksCount);
2239 }
2240
2241 void CustomTrackView::removeTrack(int ix)
2242 {
2243     // Delete track in MLT playlist
2244     m_document->renderer()->mltDeleteTrack(m_document->tracksCount() - ix);
2245     m_document->deleteTrack(m_document->tracksCount() - ix - 1);
2246
2247     double startY = ix * (m_tracksHeight + 1) + m_tracksHeight / 2;
2248     QRectF r(0, startY, sceneRect().width(), sceneRect().height() - startY);
2249     QList<QGraphicsItem *> selection = m_scene->items(r);
2250
2251     resetSelectionGroup();
2252
2253     m_selectionGroup = new AbstractGroupItem(m_document->fps());
2254     scene()->addItem(m_selectionGroup);
2255     for (int i = 0; i < selection.count(); i++) {
2256         if ((!selection.at(i)->parentItem()) && (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET || selection.at(i)->type() == GROUPWIDGET)) {
2257             m_selectionGroup->addToGroup(selection.at(i));
2258             selection.at(i)->setFlag(QGraphicsItem::ItemIsMovable, false);
2259         }
2260     }
2261     // Move graphic items
2262     qreal ydiff = 0 - (int) m_tracksHeight;
2263     m_selectionGroup->translate(0, ydiff);
2264
2265     // adjust track number
2266     QList<QGraphicsItem *> children = m_selectionGroup->childItems();
2267     //kDebug() << "// FOUND CLIPS TO MOVE: " << children.count();
2268     for (int i = 0; i < children.count(); i++) {
2269         if (children.at(i)->type() == GROUPWIDGET) {
2270             AbstractGroupItem *grp = static_cast<AbstractGroupItem*>(children.at(i));
2271             children << grp->childItems();
2272             continue;
2273         }
2274         if (children.at(i)->type() == AVWIDGET) {
2275             ClipItem *clip = static_cast <ClipItem *>(children.at(i));
2276             clip->updateItem();
2277             ItemInfo clipinfo = clip->info();
2278             // We add a move clip command so that we get the correct producer for new track number
2279             if (clip->clipType() == AV || clip->clipType() == AUDIO) {
2280                 Mlt::Producer *prod;
2281                 if (clip->isAudioOnly()) prod = clip->baseClip()->audioProducer(clipinfo.track);
2282                 else if (clip->isVideoOnly()) prod = clip->baseClip()->videoProducer();
2283                 else prod = clip->baseClip()->producer(clipinfo.track);
2284                 if (!m_document->renderer()->mltUpdateClipProducer((int)(m_document->tracksCount() - clipinfo.track), clipinfo.startPos.frames(m_document->fps()), prod)) {
2285                     emit displayMessage(i18n("Cannot update clip (time: %1, track: %2)", clipinfo.startPos.frames(m_document->fps()), clipinfo.track), ErrorMessage);
2286                 }
2287             }
2288         } else if (children.at(i)->type() == TRANSITIONWIDGET) {
2289             Transition *tr = static_cast <Transition *>(children.at(i));
2290             tr->updateItem();
2291             int track = tr->transitionEndTrack();
2292             if (track >= ix) {
2293                 ItemInfo clipinfo = tr->info();
2294                 tr->updateTransitionEndTrack(getPreviousVideoTrack(clipinfo.track));
2295             }
2296         }
2297     }
2298     resetSelectionGroup(false);
2299
2300     int maxHeight = m_tracksHeight * m_document->tracksCount();
2301     for (int i = 0; i < m_guides.count(); i++) {
2302         QLineF l = m_guides.at(i)->line();
2303         l.setP2(QPointF(l.x2(), maxHeight));
2304         m_guides.at(i)->setLine(l);
2305     }
2306     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), maxHeight);
2307     setSceneRect(0, 0, sceneRect().width(), maxHeight);
2308
2309     m_selectedTrack = qMin(m_selectedTrack, m_document->tracksCount() - 1);
2310     viewport()->update();
2311     emit tracksChanged();
2312     //QTimer::singleShot(500, this, SIGNAL(trackHeightChanged()));
2313 }
2314
2315 void CustomTrackView::changeTrack(int ix, TrackInfo type)
2316 {
2317     int tracknumber = m_document->tracksCount() - ix;
2318     m_document->setTrackType(tracknumber - 1, type);
2319     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
2320     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
2321     viewport()->update();
2322 }
2323
2324
2325 void CustomTrackView::slotSwitchTrackAudio(int ix)
2326 {
2327     /*for (int i = 0; i < m_document->tracksCount(); i++)
2328         kDebug() << "TRK " << i << " STATE: " << m_document->trackInfoAt(i).isMute << m_document->trackInfoAt(i).isBlind;*/
2329     int tracknumber = m_document->tracksCount() - ix - 1;
2330     m_document->switchTrackAudio(tracknumber, !m_document->trackInfoAt(tracknumber).isMute);
2331     kDebug() << "NEXT TRK STATE: " << m_document->trackInfoAt(tracknumber).isMute << m_document->trackInfoAt(tracknumber).isBlind;
2332     m_document->renderer()->mltChangeTrackState(tracknumber + 1, m_document->trackInfoAt(tracknumber).isMute, m_document->trackInfoAt(tracknumber).isBlind);
2333     setDocumentModified();
2334 }
2335
2336 void CustomTrackView::slotSwitchTrackLock(int ix)
2337 {
2338     int tracknumber = m_document->tracksCount() - ix - 1;
2339     LockTrackCommand *command = new LockTrackCommand(this, ix, !m_document->trackInfoAt(tracknumber).isLocked);
2340     m_commandStack->push(command);
2341 }
2342
2343
2344 void CustomTrackView::lockTrack(int ix, bool lock)
2345 {
2346     int tracknumber = m_document->tracksCount() - ix - 1;
2347     m_document->switchTrackLock(tracknumber, lock);
2348     emit doTrackLock(ix, lock);
2349     QList<QGraphicsItem *> selection = m_scene->items(0, ix * m_tracksHeight + m_tracksHeight / 2, sceneRect().width(), m_tracksHeight / 2 - 2);
2350
2351     for (int i = 0; i < selection.count(); i++) {
2352         if (selection.at(i)->type() != AVWIDGET && selection.at(i)->type() != TRANSITIONWIDGET) continue;
2353         if (selection.at(i)->isSelected()) {
2354             if (selection.at(i)->type() == AVWIDGET) emit clipItemSelected(NULL);
2355             else emit transitionItemSelected(NULL);
2356         }
2357         static_cast <AbstractClipItem *>(selection.at(i))->setItemLocked(lock);
2358     }
2359     kDebug() << "NEXT TRK STATE: " << m_document->trackInfoAt(tracknumber).isLocked;
2360     viewport()->update();
2361     setDocumentModified();
2362 }
2363
2364 void CustomTrackView::slotSwitchTrackVideo(int ix)
2365 {
2366     int tracknumber = m_document->tracksCount() - ix;
2367     m_document->switchTrackVideo(tracknumber - 1, !m_document->trackInfoAt(tracknumber - 1).isBlind);
2368     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
2369     setDocumentModified();
2370 }
2371
2372 QList<QGraphicsItem *> CustomTrackView::checkForGroups(const QRectF &rect, bool *ok)
2373 {
2374     // Check there is no group going over several tracks there, or that would result in timeline corruption
2375     QList<QGraphicsItem *> selection = scene()->items(rect);
2376     *ok = true;
2377     int maxHeight = m_tracksHeight * 1.5;
2378     for (int i = 0; i < selection.count(); i++) {
2379         // Check that we don't try to move a group with clips on other tracks
2380         if (selection.at(i)->type() == GROUPWIDGET && (selection.at(i)->boundingRect().height() >= maxHeight)) {
2381             *ok = false;
2382             break;
2383         } else if (selection.at(i)->parentItem() && (selection.at(i)->parentItem()->boundingRect().height() >= maxHeight)) {
2384             *ok = false;
2385             break;
2386         }
2387     }
2388     return selection;
2389 }
2390
2391 void CustomTrackView::slotRemoveSpace()
2392 {
2393     GenTime pos;
2394     int track = 0;
2395     if (m_menuPosition.isNull()) {
2396         pos = GenTime(cursorPos(), m_document->fps());
2397         bool ok;
2398         track = QInputDialog::getInteger(this, i18n("Remove Space"), i18n("Track"), 0, 0, m_document->tracksCount() - 1, 1, &ok);
2399         if (!ok) return;
2400     } else {
2401         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
2402         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight);
2403     }
2404
2405     ClipItem *item = getClipItemAt(pos, track);
2406     if (item) {
2407         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);
2408         return;
2409     }
2410     int length = m_document->renderer()->mltGetSpaceLength(pos, m_document->tracksCount() - track, true);
2411     //kDebug() << "// GOT LENGT; " << length;
2412     if (length <= 0) {
2413         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);
2414         return;
2415     }
2416
2417     // Make sure there is no group in the way
2418     QRectF rect(pos.frames(m_document->fps()), track * m_tracksHeight + m_tracksHeight / 2, sceneRect().width() - pos.frames(m_document->fps()), m_tracksHeight / 2 - 2);
2419
2420     bool isOk;
2421     QList<QGraphicsItem *> items = checkForGroups(rect, &isOk);
2422     if (!isOk) {
2423         // groups found on track, do not allow the move
2424         emit displayMessage(i18n("Cannot remove space in a track with a group"), ErrorMessage);
2425         return;
2426     }
2427
2428     QList<ItemInfo> clipsToMove;
2429     QList<ItemInfo> transitionsToMove;
2430
2431     for (int i = 0; i < items.count(); i++) {
2432         if (items.at(i)->type() == AVWIDGET || items.at(i)->type() == TRANSITIONWIDGET) {
2433             AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2434             ItemInfo info = item->info();
2435             if (item->type() == AVWIDGET) {
2436                 clipsToMove.append(info);
2437             } else if (item->type() == TRANSITIONWIDGET) {
2438                 transitionsToMove.append(info);
2439             }
2440         }
2441     }
2442
2443     InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, GenTime(-length, m_document->fps()), true);
2444     m_commandStack->push(command);
2445 }
2446
2447 void CustomTrackView::slotInsertSpace()
2448 {
2449     GenTime pos;
2450     int track = 0;
2451     if (m_menuPosition.isNull()) {
2452         pos = GenTime(cursorPos(), m_document->fps());
2453     } else {
2454         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
2455         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight) + 1;
2456     }
2457     SpacerDialog d(GenTime(65, m_document->fps()), m_document->timecode(), track, m_document->tracksCount(), this);
2458     if (d.exec() != QDialog::Accepted) return;
2459     GenTime spaceDuration = d.selectedDuration();
2460     track = d.selectedTrack();
2461
2462     ClipItem *item = getClipItemAt(pos, track);
2463     if (item) pos = item->startPos();
2464
2465     // Make sure there is no group in the way
2466     QRectF rect(pos.frames(m_document->fps()), track * m_tracksHeight + m_tracksHeight / 2, sceneRect().width() - pos.frames(m_document->fps()), m_tracksHeight / 2 - 2);
2467     bool isOk;
2468     QList<QGraphicsItem *> items = checkForGroups(rect, &isOk);
2469     if (!isOk) {
2470         // groups found on track, do not allow the move
2471         emit displayMessage(i18n("Cannot insert space in a track with a group"), ErrorMessage);
2472         return;
2473     }
2474
2475     QList<ItemInfo> clipsToMove;
2476     QList<ItemInfo> transitionsToMove;
2477
2478     for (int i = 0; i < items.count(); i++) {
2479         if (items.at(i)->type() == AVWIDGET || items.at(i)->type() == TRANSITIONWIDGET) {
2480             AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2481             ItemInfo info = item->info();
2482             if (item->type() == AVWIDGET) {
2483                 clipsToMove.append(info);
2484             } else if (item->type() == TRANSITIONWIDGET) {
2485                 transitionsToMove.append(info);
2486             }
2487         }
2488     }
2489
2490     InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, spaceDuration, true);
2491     m_commandStack->push(command);
2492 }
2493
2494 void CustomTrackView::insertSpace(QList<ItemInfo> clipsToMove, QList<ItemInfo> transToMove, int track, const GenTime duration, const GenTime offset)
2495 {
2496     int diff = duration.frames(m_document->fps());
2497     resetSelectionGroup();
2498     m_selectionGroup = new AbstractGroupItem(m_document->fps());
2499     scene()->addItem(m_selectionGroup);
2500     ClipItem *clip;
2501     Transition *transition;
2502
2503     // Create lists with start pos for each track
2504     QMap <int, int> trackClipStartList;
2505     QMap <int, int> trackTransitionStartList;
2506
2507     for (int i = 1; i < m_document->tracksCount() + 1; i++) {
2508         trackClipStartList[i] = -1;
2509         trackTransitionStartList[i] = -1;
2510     }
2511
2512     if (!clipsToMove.isEmpty()) for (int i = 0; i < clipsToMove.count(); i++) {
2513             clip = getClipItemAtStart(clipsToMove.at(i).startPos + offset, clipsToMove.at(i).track);
2514             if (clip) {
2515                 if (clip->parentItem()) {
2516                     m_selectionGroup->addToGroup(clip->parentItem());
2517                     clip->parentItem()->setFlag(QGraphicsItem::ItemIsMovable, false);
2518                 } else {
2519                     m_selectionGroup->addToGroup(clip);
2520                     clip->setFlag(QGraphicsItem::ItemIsMovable, false);
2521                 }
2522                 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))
2523                     trackClipStartList[m_document->tracksCount() - clipsToMove.at(i).track] = clipsToMove.at(i).startPos.frames(m_document->fps());
2524             } else emit {
2525                     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);
2526                 }
2527             }
2528     if (!transToMove.isEmpty()) for (int i = 0; i < transToMove.count(); i++) {
2529             transition = getTransitionItemAtStart(transToMove.at(i).startPos + offset, transToMove.at(i).track);
2530             if (transition) {
2531                 if (transition->parentItem()) {
2532                     m_selectionGroup->addToGroup(transition->parentItem());
2533                     transition->parentItem()->setFlag(QGraphicsItem::ItemIsMovable, false);
2534                 } else {
2535                     m_selectionGroup->addToGroup(transition);
2536                     transition->setFlag(QGraphicsItem::ItemIsMovable, false);
2537                 }
2538                 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))
2539                     trackTransitionStartList[m_document->tracksCount() - transToMove.at(i).track] = transToMove.at(i).startPos.frames(m_document->fps());
2540             } 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);
2541         }
2542     m_selectionGroup->translate(diff, 0);
2543
2544     // update items coordinates
2545     QList<QGraphicsItem *> itemList = m_selectionGroup->childItems();
2546
2547     for (int i = 0; i < itemList.count(); i++) {
2548         if (itemList.at(i)->type() == AVWIDGET || itemList.at(i)->type() == TRANSITIONWIDGET) {
2549             static_cast < AbstractClipItem *>(itemList.at(i))->updateItem();
2550         } else if (itemList.at(i)->type() == GROUPWIDGET) {
2551             QList<QGraphicsItem *> children = itemList.at(i)->childItems();
2552             for (int j = 0; j < children.count(); j++) {
2553                 AbstractClipItem * clp = static_cast < AbstractClipItem *>(children.at(j));
2554                 clp->updateItem();
2555             }
2556         }
2557     }
2558     resetSelectionGroup(false);
2559     if (track != -1) track = m_document->tracksCount() - track;
2560     m_document->renderer()->mltInsertSpace(trackClipStartList, trackTransitionStartList, track, duration, offset);
2561 }
2562
2563 void CustomTrackView::deleteClip(const QString &clipId)
2564 {
2565     resetSelectionGroup();
2566     QList<QGraphicsItem *> itemList = items();
2567     QUndoCommand *deleteCommand = new QUndoCommand();
2568     int count = 0;
2569     for (int i = 0; i < itemList.count(); i++) {
2570         if (itemList.at(i)->type() == AVWIDGET) {
2571             ClipItem *item = (ClipItem *)itemList.at(i);
2572             if (item->clipProducer() == clipId) {
2573                 count++;
2574                 if (item->parentItem()) {
2575                     // Clip is in a group, destroy the group
2576                     new GroupClipsCommand(this, QList<ItemInfo>() << item->info(), QList<ItemInfo>(), false, deleteCommand);
2577                 }
2578                 new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true, deleteCommand);
2579             }
2580         }
2581     }
2582     deleteCommand->setText(i18np("Delete timeline clip", "Delete timeline clips", count));
2583     if (count == 0) delete deleteCommand;
2584     else m_commandStack->push(deleteCommand);
2585 }
2586
2587 void CustomTrackView::setCursorPos(int pos, bool seek)
2588 {
2589     if (pos == m_cursorPos) return;
2590     emit cursorMoved((int)(m_cursorPos), (int)(pos));
2591     m_cursorPos = pos;
2592     if (seek) m_document->renderer()->seek(GenTime(m_cursorPos, m_document->fps()));
2593     else if (m_autoScroll) checkScrolling();
2594     m_cursorLine->setPos(m_cursorPos, 0);
2595 }
2596
2597 void CustomTrackView::updateCursorPos()
2598 {
2599     m_cursorLine->setPos(m_cursorPos, 0);
2600 }
2601
2602 int CustomTrackView::cursorPos()
2603 {
2604     return (int)(m_cursorPos);
2605 }
2606
2607 void CustomTrackView::moveCursorPos(int delta)
2608 {
2609     if (m_cursorPos + delta < 0) delta = 0 - m_cursorPos;
2610     emit cursorMoved((int)(m_cursorPos), (int)((m_cursorPos + delta)));
2611     m_cursorPos += delta;
2612     m_cursorLine->setPos(m_cursorPos, 0);
2613     m_document->renderer()->seek(GenTime(m_cursorPos, m_document->fps()));
2614 }
2615
2616 void CustomTrackView::initCursorPos(int pos)
2617 {
2618     emit cursorMoved((int)(m_cursorPos), (int)(pos));
2619     m_cursorPos = pos;
2620     m_cursorLine->setPos(pos, 0);
2621     checkScrolling();
2622 }
2623
2624 void CustomTrackView::checkScrolling()
2625 {
2626     ensureVisible(m_cursorPos, verticalScrollBar()->value() + 10, 2, 2, 50, 0);
2627 }
2628
2629 void CustomTrackView::mouseReleaseEvent(QMouseEvent * event)
2630 {
2631     if (m_moveOpMode == SEEK) m_moveOpMode = NONE;
2632     QGraphicsView::mouseReleaseEvent(event);
2633     setViewportUpdateMode(QGraphicsView::MinimalViewportUpdate);
2634     if (m_scrollTimer.isActive()) m_scrollTimer.stop();
2635     if (event->button() == Qt::MidButton) {
2636         return;
2637     }
2638     setDragMode(QGraphicsView::NoDrag);
2639     if (m_operationMode == MOVEGUIDE) {
2640         setCursor(Qt::ArrowCursor);
2641         m_operationMode = NONE;
2642         m_dragGuide->setFlag(QGraphicsItem::ItemIsMovable, false);
2643         GenTime newPos = GenTime(m_dragGuide->pos().x(), m_document->fps());
2644         if (newPos != m_dragGuide->position()) {
2645             EditGuideCommand *command = new EditGuideCommand(this, m_dragGuide->position(), m_dragGuide->label(), newPos, m_dragGuide->label(), false);
2646             m_commandStack->push(command);
2647             m_dragGuide->updateGuide(GenTime(m_dragGuide->pos().x(), m_document->fps()));
2648             qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
2649             m_document->syncGuides(m_guides);
2650         }
2651         m_dragGuide = NULL;
2652         m_dragItem = NULL;
2653         return;
2654     } else if (m_operationMode == SPACER && m_selectionGroup) {
2655         int track;
2656         if (event->modifiers() != Qt::ControlModifier) {
2657             // We are moving all tracks
2658             track = -1;
2659         } else track = (int)(mapToScene(m_clickEvent).y() / m_tracksHeight);
2660         GenTime timeOffset = GenTime((int)(m_selectionGroup->scenePos().x()), m_document->fps()) - m_selectionGroupInfo.startPos;
2661
2662         if (timeOffset != GenTime()) {
2663             QList<QGraphicsItem *> items = m_selectionGroup->childItems();
2664
2665             QList<ItemInfo> clipsToMove;
2666             QList<ItemInfo> transitionsToMove;
2667
2668             // Create lists with start pos for each track
2669             QMap <int, int> trackClipStartList;
2670             QMap <int, int> trackTransitionStartList;
2671
2672             for (int i = 1; i < m_document->tracksCount() + 1; i++) {
2673                 trackClipStartList[i] = -1;
2674                 trackTransitionStartList[i] = -1;
2675             }
2676
2677             for (int i = 0; i < items.count(); i++) {
2678                 if (items.at(i)->type() == GROUPWIDGET)
2679                     items += items.at(i)->childItems();
2680             }
2681
2682             for (int i = 0; i < items.count(); i++) {
2683                 if (items.at(i)->type() == AVWIDGET) {
2684                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2685                     ItemInfo info = item->info();
2686                     clipsToMove.append(info);
2687                     item->updateItem();
2688                     if (trackClipStartList.value(m_document->tracksCount() - info.track) == -1 || info.startPos.frames(m_document->fps()) < trackClipStartList.value(m_document->tracksCount() - info.track))
2689                         trackClipStartList[m_document->tracksCount() - info.track] = info.startPos.frames(m_document->fps());
2690                 } else if (items.at(i)->type() == TRANSITIONWIDGET) {
2691                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2692                     ItemInfo info = item->info();
2693                     transitionsToMove.append(info);
2694                     item->updateItem();
2695                     if (trackTransitionStartList.value(m_document->tracksCount() - info.track) == -1 || info.startPos.frames(m_document->fps()) < trackTransitionStartList.value(m_document->tracksCount() - info.track))
2696                         trackTransitionStartList[m_document->tracksCount() - info.track] = info.startPos.frames(m_document->fps());
2697                 }
2698             }
2699
2700             InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, timeOffset, false);
2701             m_commandStack->push(command);
2702             if (track != -1) track = m_document->tracksCount() - track;
2703             kDebug() << "SPACER TRACK:" << track;
2704             m_document->renderer()->mltInsertSpace(trackClipStartList, trackTransitionStartList, track, timeOffset, GenTime());
2705         }
2706         resetSelectionGroup(false);
2707         m_operationMode = NONE;
2708     } else if (m_operationMode == RUBBERSELECTION) {
2709         //kDebug() << "// END RUBBER SELECT";
2710         resetSelectionGroup();
2711         groupSelectedItems();
2712         m_operationMode = NONE;
2713     }
2714
2715     if (m_dragItem == NULL && m_selectionGroup == NULL) {
2716         emit transitionItemSelected(NULL);
2717         return;
2718     }
2719     ItemInfo info;
2720     if (m_dragItem) info = m_dragItem->info();
2721
2722     if (m_operationMode == MOVE) {
2723         setCursor(Qt::OpenHandCursor);
2724         if (m_dragItem) m_dragItem->setZValue(m_dragItem->defaultZValue());
2725         if (m_selectionGroup) m_selectionGroup->setZValue(1);
2726         if (m_dragItem->parentItem() == 0) {
2727             // we are moving one clip, easy
2728             if (m_dragItem->type() == AVWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
2729                 ClipItem *item = static_cast <ClipItem *>(m_dragItem);
2730                 Mlt::Producer *prod;
2731                 if (item->isAudioOnly()) prod = item->baseClip()->audioProducer(m_dragItemInfo.track);
2732                 else if (item->isVideoOnly()) prod = item->baseClip()->videoProducer();
2733                 else prod = item->baseClip()->producer(m_dragItemInfo.track);
2734                 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);
2735
2736                 if (success) {
2737                     QUndoCommand *moveCommand = new QUndoCommand();
2738                     moveCommand->setText(i18n("Move clip"));
2739                     adjustTimelineClips(m_scene->editMode(), item, moveCommand);
2740
2741                     int tracknumber = m_document->tracksCount() - item->track() - 1;
2742                     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2743                     if (isLocked) item->setItemLocked(true);
2744                     new MoveClipCommand(this, m_dragItemInfo, info, false, moveCommand);
2745                     // Also move automatic transitions (on lower track)
2746                     Transition *startTransition = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track);
2747                     ItemInfo startTrInfo;
2748                     ItemInfo newStartTrInfo;
2749                     bool moveStartTrans = false;
2750                     bool moveEndTrans = false;
2751                     if (startTransition && startTransition->isAutomatic()) {
2752                         startTrInfo = startTransition->info();
2753                         newStartTrInfo = startTrInfo;
2754                         newStartTrInfo.track = info.track;
2755                         newStartTrInfo.startPos = info.startPos;
2756                         if (m_dragItemInfo.track == info.track && !item->baseClip()->isTransparent() && getClipItemAtEnd(newStartTrInfo.endPos, m_document->tracksCount() - startTransition->transitionEndTrack())) {
2757                             // transition end should stay the same
2758                         } else {
2759                             // transition end should be adjusted to clip
2760                             newStartTrInfo.endPos = newStartTrInfo.endPos + (newStartTrInfo.startPos - startTrInfo.startPos);
2761                         }
2762                         if (newStartTrInfo.startPos < newStartTrInfo.endPos) moveStartTrans = true;
2763                     }
2764                     if (startTransition == NULL || startTransition->endPos() < m_dragItemInfo.endPos) {
2765                         // Check if there is a transition at clip end
2766                         Transition *tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track);
2767                         if (tr && tr->isAutomatic()) {
2768                             ItemInfo trInfo = tr->info();
2769                             ItemInfo newTrInfo = trInfo;
2770                             newTrInfo.track = info.track;
2771                             newTrInfo.endPos = m_dragItem->endPos();
2772                             if (m_dragItemInfo.track == info.track && !item->baseClip()->isTransparent() && getClipItemAtStart(trInfo.startPos, m_document->tracksCount() - tr->transitionEndTrack())) {
2773                                 // transition start should stay the same
2774                             } else {
2775                                 // transition start should be moved
2776                                 newTrInfo.startPos = newTrInfo.startPos + (newTrInfo.endPos - trInfo.endPos);
2777                             }
2778                             if (newTrInfo.startPos < newTrInfo.endPos) {
2779                                 moveEndTrans = true;
2780                                 if (moveStartTrans) {
2781                                     // we have to move both transitions, remove the start one so that there is no collision
2782                                     new AddTransitionCommand(this, startTrInfo, startTransition->transitionEndTrack(), startTransition->toXML(), true, true, moveCommand);
2783                                 }
2784                                 adjustTimelineTransitions(m_scene->editMode(), tr, moveCommand);
2785                                 new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2786                                 if (moveStartTrans) {
2787                                     // re-add transition in correct place
2788                                     int transTrack = startTransition->transitionEndTrack();
2789                                     if (m_dragItemInfo.track != info.track && !startTransition->forcedTrack()) {
2790                                         transTrack = getPreviousVideoTrack(info.track);
2791                                     }
2792                                     adjustTimelineTransitions(m_scene->editMode(), startTransition, moveCommand);
2793                                     new AddTransitionCommand(this, newStartTrInfo, transTrack, startTransition->toXML(), false, true, moveCommand);
2794                                 }
2795                             }
2796                         }
2797                     }
2798
2799                     if (moveStartTrans && !moveEndTrans) {
2800                         adjustTimelineTransitions(m_scene->editMode(), startTransition, moveCommand);
2801                         new MoveTransitionCommand(this, startTrInfo, newStartTrInfo, true, moveCommand);
2802                     }
2803
2804                     // Also move automatic transitions (on upper track)
2805                     Transition *tr = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2806                     if (m_dragItemInfo.track == info.track && tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
2807                         ItemInfo trInfo = tr->info();
2808                         ItemInfo newTrInfo = trInfo;
2809                         newTrInfo.startPos = m_dragItem->startPos();
2810                         ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2811                         if (!upperClip || !upperClip->baseClip()->isTransparent()) {
2812                             if (!getClipItemAtEnd(newTrInfo.endPos, tr->track())) {
2813                                 // transition end should be adjusted to clip on upper track
2814                                 newTrInfo.endPos = newTrInfo.endPos + (newTrInfo.startPos - trInfo.startPos);
2815                             }
2816                             if (newTrInfo.startPos < newTrInfo.endPos) {
2817                                 adjustTimelineTransitions(m_scene->editMode(), tr, moveCommand);
2818                                 new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2819                             }
2820                         }
2821                     }
2822                     if (m_dragItemInfo.track == info.track && (tr == NULL || tr->endPos() < m_dragItemInfo.endPos)) {
2823                         // Check if there is a transition at clip end
2824                         tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
2825                         if (tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
2826                             ItemInfo trInfo = tr->info();
2827                             ItemInfo newTrInfo = trInfo;
2828                             newTrInfo.endPos = m_dragItem->endPos();
2829                             kDebug() << "CLIP ENDS AT: " << newTrInfo.endPos.frames(25);
2830                             kDebug() << "CLIP STARTS AT: " << newTrInfo.startPos.frames(25);
2831                             ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2832                             if (!upperClip || !upperClip->baseClip()->isTransparent()) {
2833                                 if (!getClipItemAtStart(trInfo.startPos, tr->track())) {
2834                                     // transition start should be moved
2835                                     newTrInfo.startPos = newTrInfo.startPos + (newTrInfo.endPos - trInfo.endPos);
2836                                 }
2837                                 if (newTrInfo.startPos < newTrInfo.endPos) {
2838                                     adjustTimelineTransitions(m_scene->editMode(), tr, moveCommand);
2839                                     new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2840                                 }
2841                             }
2842                         }
2843                     }
2844                     m_commandStack->push(moveCommand);
2845                     //checkTrackSequence(m_dragItem->track());
2846                 } else {
2847                     // undo last move and emit error message
2848                     bool snap = KdenliveSettings::snaptopoints();
2849                     KdenliveSettings::setSnaptopoints(false);
2850                     item->setPos((int) m_dragItemInfo.startPos.frames(m_document->fps()), (int)(m_dragItemInfo.track * m_tracksHeight + 1));
2851                     KdenliveSettings::setSnaptopoints(snap);
2852                     emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(m_dragItemInfo.startPos.frames(m_document->fps()))), ErrorMessage);
2853                 }
2854                 setDocumentModified();
2855             }
2856             if (m_dragItem->type() == TRANSITIONWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
2857                 Transition *transition = static_cast <Transition *>(m_dragItem);
2858                 transition->updateTransitionEndTrack(getPreviousVideoTrack(m_dragItem->track()));
2859                 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)) {
2860                     // Moving transition failed, revert to previous position
2861                     emit displayMessage(i18n("Cannot move transition"), ErrorMessage);
2862                     transition->setPos((int) m_dragItemInfo.startPos.frames(m_document->fps()), (m_dragItemInfo.track) * m_tracksHeight + 1);
2863                 } else {
2864                     QUndoCommand *moveCommand = new QUndoCommand();
2865                     moveCommand->setText(i18n("Move transition"));
2866                     adjustTimelineTransitions(m_scene->editMode(), transition, moveCommand);
2867                     new MoveTransitionCommand(this, m_dragItemInfo, info, false, moveCommand);
2868                     m_commandStack->push(moveCommand);
2869                 }
2870             }
2871         } else {
2872             // Moving several clips. We need to delete them and readd them to new position,
2873             // or they might overlap each other during the move
2874             QGraphicsItemGroup *group = static_cast <QGraphicsItemGroup *>(m_dragItem->parentItem());
2875             QList<QGraphicsItem *> items = group->childItems();
2876
2877             QList<ItemInfo> clipsToMove;
2878             QList<ItemInfo> transitionsToMove;
2879
2880             GenTime timeOffset = GenTime(m_dragItem->scenePos().x(), m_document->fps()) - m_dragItemInfo.startPos;
2881             const int trackOffset = (int)(m_dragItem->scenePos().y() / m_tracksHeight) - m_dragItemInfo.track;
2882             //kDebug() << "// MOVED SEVERAL CLIPS" << timeOffset.frames(25);
2883             QUndoCommand *moveGroup = new QUndoCommand();
2884             moveGroup->setText(i18n("Move group"));
2885             if (timeOffset != GenTime() || trackOffset != 0) {
2886                 // remove items in MLT playlist
2887
2888                 // Expand groups
2889                 int max = items.count();
2890                 for (int i = 0; i < max; i++) {
2891                     if (items.at(i)->type() == GROUPWIDGET) {
2892                         items += items.at(i)->childItems();
2893                     }
2894                 }
2895                 m_document->renderer()->blockSignals(true);
2896                 for (int i = 0; i < items.count(); i++) {
2897                     if (items.at(i)->type() != AVWIDGET && items.at(i)->type() != TRANSITIONWIDGET) continue;
2898                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2899                     ItemInfo info = item->info();
2900                     if (item->type() == AVWIDGET) {
2901                         if (m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
2902                             // error, clip cannot be removed from playlist
2903                             emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
2904                         } else {
2905                             clipsToMove.append(info);
2906                         }
2907                     } else {
2908                         transitionsToMove.append(info);
2909                         Transition *tr = static_cast <Transition*>(item);
2910                         m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2911                     }
2912                 }
2913                 m_document->renderer()->blockSignals(false);
2914                 for (int i = 0; i < items.count(); i++) {
2915                     // re-add items in correct place
2916                     if (items.at(i)->type() != AVWIDGET && items.at(i)->type() != TRANSITIONWIDGET) continue;
2917                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2918                     item->updateItem();
2919                     ItemInfo info = item->info();
2920                     int tracknumber = m_document->tracksCount() - info.track - 1;
2921                     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2922                     if (isLocked) {
2923                         group->removeFromGroup(item);
2924                         item->setItemLocked(true);
2925                     }
2926
2927                     if (item->type() == AVWIDGET) {
2928                         ClipItem *clip = static_cast <ClipItem*>(item);
2929                         info.track = m_document->tracksCount() - info.track;
2930                         Mlt::Producer *prod;
2931                         adjustTimelineClips(m_scene->editMode(), clip, moveGroup);
2932                         if (clip->isAudioOnly()) prod = clip->baseClip()->audioProducer(info.track);
2933                         else if (clip->isVideoOnly()) prod = clip->baseClip()->videoProducer();
2934                         else prod = clip->baseClip()->producer(info.track);
2935                         m_document->renderer()->mltInsertClip(info, clip->xml(), prod, m_scene->editMode() == OVERWRITEEDIT, m_scene->editMode() == INSERTEDIT);
2936                         for (int i = 0; i < clip->effectsCount(); i++) {
2937                             m_document->renderer()->mltAddEffect(info.track, info.startPos, clip->getEffectArgs(clip->effectAt(i)), false);
2938                         }
2939                     } else {
2940                         Transition *tr = static_cast <Transition*>(item);
2941                         int newTrack = tr->transitionEndTrack();
2942                         if (!tr->forcedTrack()) {
2943                             newTrack = getPreviousVideoTrack(info.track);
2944                         }
2945                         tr->updateTransitionEndTrack(newTrack);
2946                         adjustTimelineTransitions(m_scene->editMode(), tr, moveGroup);
2947                         m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2948                     }
2949                 }
2950
2951                 new MoveGroupCommand(this, clipsToMove, transitionsToMove, timeOffset, trackOffset, false, moveGroup);
2952                 m_commandStack->push(moveGroup);
2953
2954                 //QPointF top = group->sceneBoundingRect().topLeft();
2955                 //QPointF oldpos = m_selectionGroup->scenePos();
2956                 //kDebug()<<"SELECTION GRP POS: "<<m_selectionGroup->scenePos()<<", TOP: "<<top;
2957                 //group->setPos(top);
2958                 //TODO: get rid of the 3 lines below
2959                 if (m_selectionGroup) {
2960                     m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
2961                     m_selectionGroupInfo.track = m_selectionGroup->track();
2962                 }
2963                 setDocumentModified();
2964             }
2965         }
2966         m_document->renderer()->doRefresh();
2967     } else if (m_operationMode == RESIZESTART && m_dragItem->startPos() != m_dragItemInfo.startPos) {
2968         // resize start
2969         if (m_dragItem->type() == AVWIDGET) {
2970             ItemInfo resizeinfo = m_dragItemInfo;
2971             resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
2972             bool success = m_document->renderer()->mltResizeClipStart(resizeinfo, m_dragItem->startPos() - m_dragItemInfo.startPos);
2973             if (success) {
2974                 QUndoCommand *resizeCommand = new QUndoCommand();
2975                 resizeCommand->setText(i18n("Resize clip"));
2976
2977                 // Check if there is an automatic transition on that clip (lower track)
2978                 Transition *transition = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track);
2979                 if (transition && transition->isAutomatic()) {
2980                     ItemInfo trInfo = transition->info();
2981                     ItemInfo newTrInfo = trInfo;
2982                     newTrInfo.startPos = m_dragItem->startPos();
2983                     if (newTrInfo.startPos < newTrInfo.endPos)
2984                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2985                 }
2986                 // Check if there is an automatic transition on that clip (upper track)
2987                 transition = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2988                 if (transition && transition->isAutomatic() && (m_document->tracksCount() - transition->transitionEndTrack()) == m_dragItemInfo.track) {
2989                     ItemInfo trInfo = transition->info();
2990                     ItemInfo newTrInfo = trInfo;
2991                     newTrInfo.startPos = m_dragItem->startPos();
2992                     ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2993                     if ((!upperClip || !upperClip->baseClip()->isTransparent()) && newTrInfo.startPos < newTrInfo.endPos) {
2994                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2995                     }
2996                 }
2997
2998                 ClipItem *clip = static_cast < ClipItem * >(m_dragItem);
2999                 updatePositionEffects(clip, m_dragItemInfo);
3000
3001                 // check keyframes
3002                 QDomDocument doc;
3003                 QDomElement root = doc.createElement("list");
3004                 doc.appendChild(root);
3005                 QList <int> indexes;
3006                 for (int i = 0; i < clip->effectsCount(); i++) {
3007                     QDomElement effect = clip->effectAt(i);
3008                     if (EffectsList::hasKeyFrames(effect)) {
3009                         doc.appendChild(doc.importNode(effect, true));
3010                         indexes.append(i);
3011                     }
3012                 }
3013
3014                 if (clip->checkEffectsKeyframesPos(m_dragItemInfo.cropStart.frames(m_document->fps()), clip->cropStart().frames(m_document->fps()), true)) {
3015                     // Keyframes were modified, updateClip
3016                     QDomNodeList effs = doc.elementsByTagName("effect");
3017                     // Hack:
3018                     // Since we must always resize clip before updating the keyframes, we
3019                     // put a resize command before & after checking keyframes so that
3020                     // we are sure the resize is performed before whenever we do or undo the action
3021
3022                     new ResizeClipCommand(this, m_dragItemInfo, info, false, true, resizeCommand);
3023                     for (int i = 0; i < indexes.count(); i++) {
3024                         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);
3025                         updateEffect(m_document->tracksCount() - clip->track(), clip->startPos(), clip->effectAt(indexes.at(i)), indexes.at(i));
3026                     }
3027                     new ResizeClipCommand(this, m_dragItemInfo, info, false, true, resizeCommand);
3028                     emit clipItemSelected(clip);
3029                 } else new ResizeClipCommand(this, m_dragItemInfo, info, false, false, resizeCommand);
3030
3031                 m_commandStack->push(resizeCommand);
3032             } else {
3033                 bool snap = KdenliveSettings::snaptopoints();
3034                 KdenliveSettings::setSnaptopoints(false);
3035                 m_dragItem->resizeStart((int) m_dragItemInfo.startPos.frames(m_document->fps()));
3036                 KdenliveSettings::setSnaptopoints(snap);
3037                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
3038             }
3039         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
3040             Transition *transition = static_cast <Transition *>(m_dragItem);
3041             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)) {
3042                 // Cannot resize transition
3043                 bool snap = KdenliveSettings::snaptopoints();
3044                 KdenliveSettings::setSnaptopoints(false);
3045                 transition->resizeStart((int) m_dragItemInfo.startPos.frames(m_document->fps()));
3046                 KdenliveSettings::setSnaptopoints(snap);
3047                 emit displayMessage(i18n("Cannot resize transition"), ErrorMessage);
3048             } else {
3049                 MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
3050                 m_commandStack->push(command);
3051             }
3052
3053         }
3054         if (m_dragItem->parentItem() && m_dragItem->parentItem() != m_selectionGroup) {
3055             // Item was resized, rebuild group;
3056             AbstractGroupItem *group = static_cast <AbstractGroupItem *>(m_dragItem->parentItem());
3057             QList <QGraphicsItem *> children = group->childItems();
3058             m_document->clipManager()->removeGroup(group);
3059             scene()->destroyItemGroup(group);
3060             for (int i = 0; i < children.count(); i++) {
3061                 children.at(i)->setSelected(true);
3062             }
3063             groupSelectedItems(false, true);
3064         }
3065         //m_document->renderer()->doRefresh();
3066     } else if (m_operationMode == RESIZEEND && m_dragItem->endPos() != m_dragItemInfo.endPos) {
3067         // resize end
3068         if (m_dragItem->type() == AVWIDGET) {
3069             ItemInfo resizeinfo = info;
3070             resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
3071             bool success = m_document->renderer()->mltResizeClipEnd(resizeinfo, resizeinfo.endPos - resizeinfo.startPos);
3072             if (success) {
3073                 QUndoCommand *resizeCommand = new QUndoCommand();
3074                 resizeCommand->setText(i18n("Resize clip"));
3075
3076                 // Check if there is an automatic transition on that clip (lower track)
3077                 Transition *tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track);
3078                 if (tr && tr->isAutomatic()) {
3079                     ItemInfo trInfo = tr->info();
3080                     ItemInfo newTrInfo = trInfo;
3081                     newTrInfo.endPos = m_dragItem->endPos();
3082                     if (newTrInfo.endPos > newTrInfo.startPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
3083                 }
3084
3085                 // Check if there is an automatic transition on that clip (upper track)
3086                 tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
3087                 if (tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
3088                     ItemInfo trInfo = tr->info();
3089                     ItemInfo newTrInfo = trInfo;
3090                     newTrInfo.endPos = m_dragItem->endPos();
3091                     ClipItem * upperClip = getClipItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
3092                     if ((!upperClip || !upperClip->baseClip()->isTransparent()) && newTrInfo.endPos > newTrInfo.startPos) {
3093                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
3094                     }
3095                 }
3096
3097                 // check keyframes
3098                 ClipItem *clip = static_cast < ClipItem * >(m_dragItem);
3099                 QDomDocument doc;
3100                 QDomElement root = doc.createElement("list");
3101                 doc.appendChild(root);
3102                 QList <int> indexes;
3103                 for (int i = 0; i < clip->effectsCount(); i++) {
3104                     QDomElement effect = clip->effectAt(i);
3105                     if (EffectsList::hasKeyFrames(effect)) {
3106                         doc.appendChild(doc.importNode(effect, true));
3107                         indexes.append(i);
3108                     }
3109                 }
3110
3111                 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)) {
3112                     // Keyframes were modified, updateClip
3113                     QDomNodeList effs = doc.elementsByTagName("effect");
3114                     // Hack:
3115                     // Since we must always resize clip before updating the keyframes, we
3116                     // put a resize command before & after checking keyframes so that
3117                     // we are sure the resize is performed before whenever we do or undo the action
3118
3119                     new ResizeClipCommand(this, m_dragItemInfo, info, false, true, resizeCommand);
3120                     for (int i = 0; i < indexes.count(); i++) {
3121                         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);
3122                         updateEffect(m_document->tracksCount() - clip->track(), clip->startPos(), clip->effectAt(indexes.at(i)), indexes.at(i));
3123                     }
3124                     new ResizeClipCommand(this, m_dragItemInfo, info, false, true, resizeCommand);
3125                     emit clipItemSelected(clip);
3126                 } else new ResizeClipCommand(this, m_dragItemInfo, info, false, false, resizeCommand);
3127
3128                 m_commandStack->push(resizeCommand);
3129                 updatePositionEffects(clip, m_dragItemInfo);
3130             } else {
3131                 m_dragItem->resizeEnd((int) m_dragItemInfo.endPos.frames(m_document->fps()));
3132                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
3133             }
3134         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
3135             Transition *transition = static_cast <Transition *>(m_dragItem);
3136             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)) {
3137                 // Cannot resize transition
3138                 transition->resizeEnd((int) m_dragItemInfo.endPos.frames(m_document->fps()));
3139                 emit displayMessage(i18n("Cannot resize transition"), ErrorMessage);
3140             } else {
3141                 MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
3142                 m_commandStack->push(command);
3143             }
3144         }
3145         if (m_dragItem->parentItem() && m_dragItem->parentItem() != m_selectionGroup) {
3146             // Item was resized, rebuild group;
3147             AbstractGroupItem *group = static_cast <AbstractGroupItem *>(m_dragItem->parentItem());
3148             QList <QGraphicsItem *> children = group->childItems();
3149             m_document->clipManager()->removeGroup(group);
3150             scene()->destroyItemGroup(group);
3151             for (int i = 0; i < children.count(); i++) {
3152                 children.at(i)->setSelected(true);
3153             }
3154             groupSelectedItems(false, true);
3155         }
3156         //m_document->renderer()->doRefresh();
3157     } else if (m_operationMode == FADEIN) {
3158         // resize fade in effect
3159         ClipItem * item = static_cast <ClipItem *>(m_dragItem);
3160         int ix = item->hasEffect("volume", "fadein");
3161         int ix2 = item->hasEffect("", "fade_from_black");
3162         if (ix != -1) {
3163             QDomElement oldeffect = item->effectAt(ix);
3164             int start = item->cropStart().frames(m_document->fps());
3165             int end = item->fadeIn();
3166             if (end == 0) {
3167                 slotDeleteEffect(item, oldeffect);
3168             } else {
3169                 end += start;
3170                 QDomElement effect = oldeffect.cloneNode().toElement();
3171                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
3172                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
3173                 slotUpdateClipEffect(item, effect, oldeffect, ix);
3174                 emit clipItemSelected(item, ix);
3175             }
3176         } else if (item->fadeIn() != 0 && ix2 == -1) {
3177             QDomElement effect;
3178             if (item->isVideoOnly() || (item->clipType() != AUDIO && item->clipType() != AV && item->clipType() != PLAYLIST)) {
3179                 // add video fade
3180                 effect = MainWindow::videoEffects.getEffectByTag("", "fade_from_black").cloneNode().toElement();
3181             } else effect = MainWindow::audioEffects.getEffectByTag("volume", "fadein").cloneNode().toElement();
3182             EffectsList::setParameter(effect, "out", QString::number(item->fadeIn()));
3183             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
3184         }
3185         if (ix2 != -1) {
3186             QDomElement oldeffect = item->effectAt(ix2);
3187             int start = item->cropStart().frames(m_document->fps());
3188             int end = item->fadeIn();
3189             if (end == 0) {
3190                 slotDeleteEffect(item, oldeffect);
3191             } else {
3192                 end += start;
3193                 QDomElement effect = oldeffect.cloneNode().toElement();
3194                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
3195                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
3196                 slotUpdateClipEffect(item, effect, oldeffect, ix2);
3197                 emit clipItemSelected(item, ix2);
3198             }
3199         }
3200     } else if (m_operationMode == FADEOUT) {
3201         // resize fade in effect
3202         ClipItem * item = static_cast <ClipItem *>(m_dragItem);
3203         int ix = item->hasEffect("volume", "fadeout");
3204         int ix2 = item->hasEffect("", "fade_to_black");
3205         if (ix != -1) {
3206             QDomElement oldeffect = item->effectAt(ix);
3207             int end = (item->cropDuration() + item->cropStart()).frames(m_document->fps());
3208             int start = item->fadeOut();
3209             if (start == 0) {
3210                 slotDeleteEffect(item, oldeffect);
3211             } else {
3212                 start = end - start;
3213                 QDomElement effect = oldeffect.cloneNode().toElement();
3214                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
3215                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
3216                 // kDebug()<<"EDIT FADE OUT : "<<start<<"x"<<end;
3217                 slotUpdateClipEffect(item, effect, oldeffect, ix);
3218                 emit clipItemSelected(item, ix);
3219             }
3220         } else if (item->fadeOut() != 0 && ix2 == -1) {
3221             QDomElement effect;
3222             if (item->isVideoOnly() || (item->clipType() != AUDIO && item->clipType() != AV && item->clipType() != PLAYLIST)) {
3223                 // add video fade
3224                 effect = MainWindow::videoEffects.getEffectByTag("", "fade_to_black").cloneNode().toElement();
3225             } else effect = MainWindow::audioEffects.getEffectByTag("volume", "fadeout").cloneNode().toElement();
3226             EffectsList::setParameter(effect, "in", QString::number(item->fadeOut()));
3227             EffectsList::setParameter(effect, "out", QString::number(0));
3228             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
3229         }
3230         if (ix2 != -1) {
3231             QDomElement oldeffect = item->effectAt(ix2);
3232             int end = (item->cropDuration() + item->cropStart()).frames(m_document->fps());
3233             int start = item->fadeOut();
3234             if (start == 0) {
3235                 slotDeleteEffect(item, oldeffect);
3236             } else {
3237                 start = end - start;
3238                 QDomElement effect = oldeffect.cloneNode().toElement();
3239                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
3240                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
3241                 // kDebug()<<"EDIT FADE OUT : "<<start<<"x"<<end;
3242                 slotUpdateClipEffect(item, effect, oldeffect, ix2);
3243                 emit clipItemSelected(item, ix2);
3244             }
3245         }
3246     } else if (m_operationMode == KEYFRAME) {
3247         // update the MLT effect
3248         ClipItem * item = static_cast <ClipItem *>(m_dragItem);
3249         QString previous = item->keyframes(item->selectedEffectIndex());
3250         item->updateKeyframeEffect();
3251         QString next = item->keyframes(item->selectedEffectIndex());
3252         EditKeyFrameCommand *command = new EditKeyFrameCommand(this, item->track(), item->startPos(), item->selectedEffectIndex(), previous, next, false);
3253         m_commandStack->push(command);
3254         updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
3255         emit clipItemSelected(item, item->selectedEffectIndex());
3256     }
3257     if (m_dragItem && m_dragItem->type() == TRANSITIONWIDGET && m_dragItem->isSelected()) {
3258         // A transition is selected
3259         QPoint p;
3260         ClipItem *transitionClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track);
3261         if (transitionClip && transitionClip->baseClip()) {
3262             QString size = transitionClip->baseClip()->getProperty("frame_size");
3263             double factor = transitionClip->baseClip()->getProperty("aspect_ratio").toDouble();
3264             p.setX((int)(size.section('x', 0, 0).toInt() * factor + 0.5));
3265             p.setY(size.section('x', 1, 1).toInt());
3266         }
3267         emit transitionItemSelected(static_cast <Transition *>(m_dragItem), getPreviousVideoTrack(m_dragItem->track()), p);
3268     } else emit transitionItemSelected(NULL);
3269     if (m_operationMode != NONE && m_operationMode != MOVE) setDocumentModified();
3270     m_operationMode = NONE;
3271 }
3272
3273 void CustomTrackView::deleteClip(ItemInfo info, bool refresh)
3274 {
3275     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
3276
3277     if (!item || m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
3278         emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
3279         return;
3280     }
3281     if (item->isSelected()) emit clipItemSelected(NULL);
3282     item->baseClip()->removeReference();
3283     m_document->updateClip(item->baseClip()->getId());
3284
3285     /*if (item->baseClip()->isTransparent()) {
3286         // also remove automatic transition
3287         Transition *tr = getTransitionItemAt(info.startPos, info.track);
3288         if (tr && tr->isAutomatic()) {
3289             m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
3290             scene()->removeItem(tr);
3291             delete tr;
3292         }
3293     }*/
3294     m_waitingThumbs.removeAll(item);
3295     if (m_dragItem == item) m_dragItem = NULL;
3296 #if QT_VERSION >= 0x040600
3297     // animate item deletion
3298     item->closeAnimation();
3299 #else
3300     delete item;
3301     item = NULL;
3302 #endif
3303
3304     setDocumentModified();
3305     if (refresh) m_document->renderer()->doRefresh();
3306 }
3307
3308 void CustomTrackView::deleteSelectedClips()
3309 {
3310     resetSelectionGroup();
3311     QList<QGraphicsItem *> itemList = scene()->selectedItems();
3312     if (itemList.count() == 0) {
3313         emit displayMessage(i18n("Select clip to delete"), ErrorMessage);
3314         return;
3315     }
3316     scene()->clearSelection();
3317     QUndoCommand *deleteSelected = new QUndoCommand();
3318
3319     bool resetGroup = false;
3320     int groupCount = 0;
3321     int clipCount = 0;
3322     int transitionCount = 0;
3323     // expand & destroy groups
3324     for (int i = 0; i < itemList.count(); i++) {
3325         if (itemList.at(i)->type() == GROUPWIDGET) {
3326             groupCount++;
3327             QList<QGraphicsItem *> children = itemList.at(i)->childItems();
3328             itemList += children;
3329             QList <ItemInfo> clipInfos;
3330             QList <ItemInfo> transitionInfos;
3331             GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
3332             for (int j = 0; j < children.count(); j++) {
3333                 if (children.at(j)->type() == AVWIDGET) {
3334                     AbstractClipItem *clip = static_cast <AbstractClipItem *>(children.at(j));
3335                     if (!clip->isItemLocked()) clipInfos.append(clip->info());
3336                 } else if (children.at(j)->type() == TRANSITIONWIDGET) {
3337                     AbstractClipItem *clip = static_cast <AbstractClipItem *>(children.at(j));
3338                     if (!clip->isItemLocked()) transitionInfos.append(clip->info());
3339                 }
3340             }
3341             if (clipInfos.count() > 0) {
3342                 new GroupClipsCommand(this, clipInfos, transitionInfos, false, deleteSelected);
3343             }
3344         }
3345     }
3346
3347     for (int i = 0; i < itemList.count(); i++) {
3348         if (itemList.at(i)->type() == AVWIDGET) {
3349             clipCount++;
3350             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
3351             if (item->parentItem()) resetGroup = true;
3352             //kDebug()<<"// DELETE CLP AT: "<<item->info().startPos.frames(25);
3353             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true, deleteSelected);
3354             emit clipItemSelected(NULL);
3355         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
3356             transitionCount++;
3357             Transition *item = static_cast <Transition *>(itemList.at(i));
3358             //kDebug()<<"// DELETE TRANS AT: "<<item->info().startPos.frames(25);
3359             if (item->parentItem()) resetGroup = true;
3360             new AddTransitionCommand(this, item->info(), item->transitionEndTrack(), item->toXML(), true, true, deleteSelected);
3361             emit transitionItemSelected(NULL);
3362         }
3363     }
3364     if (groupCount > 0 && clipCount == 0 && transitionCount == 0)
3365         deleteSelected->setText(i18np("Delete selected group", "Delete selected groups", groupCount));
3366     else if (clipCount > 0 && groupCount == 0 && transitionCount == 0)
3367         deleteSelected->setText(i18np("Delete selected clip", "Delete selected clips", clipCount));
3368     else if (transitionCount > 0 && groupCount == 0 && clipCount == 0)
3369         deleteSelected->setText(i18np("Delete selected transition", "Delete selected transitions", transitionCount));
3370     else deleteSelected->setText(i18n("Delete selected items"));
3371     m_commandStack->push(deleteSelected);
3372 }
3373
3374 void CustomTrackView::changeClipSpeed()
3375 {
3376     QList<QGraphicsItem *> itemList = scene()->selectedItems();
3377     if (itemList.count() == 0) {
3378         emit displayMessage(i18n("Select clip to change speed"), ErrorMessage);
3379         return;
3380     }
3381     QUndoCommand *changeSelected = new QUndoCommand();
3382     changeSelected->setText("Edit clip speed");
3383     int count = 0;
3384     int percent = -1;
3385     bool ok;
3386     for (int i = 0; i < itemList.count(); i++) {
3387         if (itemList.at(i)->type() == AVWIDGET) {
3388             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
3389             ItemInfo info = item->info();
3390             if (percent == -1) percent = QInputDialog::getInteger(this, i18n("Edit Clip Speed"), i18n("New speed (percents)"), item->speed() * 100, 1, 10000, 1, &ok);
3391             if (!ok) break;
3392             double speed = (double) percent / 100.0;
3393             if (item->speed() != speed && (item->clipType() == VIDEO || item->clipType() == AV)) {
3394                 count++;
3395                 //new ChangeSpeedCommand(this, info, item->speed(), speed, item->clipProducer(), changeSelected);
3396             }
3397         }
3398     }
3399     if (count > 0) m_commandStack->push(changeSelected);
3400     else delete changeSelected;
3401 }
3402
3403 void CustomTrackView::doChangeClipSpeed(ItemInfo info, ItemInfo speedIndependantInfo, const double speed, const double oldspeed, int strobe, const QString &id)
3404 {
3405     DocClipBase *baseclip = m_document->clipManager()->getClipById(id);
3406     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
3407     if (!item) {
3408         kDebug() << "ERROR: Cannot find clip for speed change";
3409         emit displayMessage(i18n("Cannot find clip for speed change"), ErrorMessage);
3410         return;
3411     }
3412     info.track = m_document->tracksCount() - item->track();
3413     int endPos = m_document->renderer()->mltChangeClipSpeed(info, speedIndependantInfo, speed, oldspeed, strobe, baseclip->producer());
3414     if (endPos >= 0) {
3415         item->setSpeed(speed, strobe);
3416         item->updateRectGeometry();
3417         if (item->cropDuration().frames(m_document->fps()) != endPos) {
3418             item->resizeEnd((int) info.startPos.frames(m_document->fps()) + endPos - 1);
3419         }
3420         updatePositionEffects(item, info);
3421         setDocumentModified();
3422     } else emit displayMessage(i18n("Invalid clip"), ErrorMessage);
3423 }
3424
3425 void CustomTrackView::cutSelectedClips()
3426 {
3427     QList<QGraphicsItem *> itemList = scene()->selectedItems();
3428     GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
3429     for (int i = 0; i < itemList.count(); i++) {
3430         if (itemList.at(i)->type() == AVWIDGET) {
3431             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
3432             if (item->parentItem() && item->parentItem() != m_selectionGroup) {
3433                 emit displayMessage(i18n("Cannot cut a clip in a group"), ErrorMessage);
3434             } else if (currentPos > item->startPos() && currentPos <  item->endPos()) {
3435                 RazorClipCommand *command = new RazorClipCommand(this, item->info(), currentPos);
3436                 m_commandStack->push(command);
3437             }
3438         }
3439     }
3440 }
3441
3442 void CustomTrackView::groupClips(bool group)
3443 {
3444     QList<QGraphicsItem *> itemList = scene()->selectedItems();
3445     QList <ItemInfo> clipInfos;
3446     QList <ItemInfo> transitionInfos;
3447     GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
3448
3449     // Expand groups
3450     int max = itemList.count();
3451     for (int i = 0; i < max; i++) {
3452         if (itemList.at(i)->type() == GROUPWIDGET) {
3453             itemList += itemList.at(i)->childItems();
3454         }
3455     }
3456
3457     for (int i = 0; i < itemList.count(); i++) {
3458         if (itemList.at(i)->type() == AVWIDGET) {
3459             AbstractClipItem *clip = static_cast <AbstractClipItem *>(itemList.at(i));
3460             if (!clip->isItemLocked()) clipInfos.append(clip->info());
3461         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
3462             AbstractClipItem *clip = static_cast <AbstractClipItem *>(itemList.at(i));
3463             if (!clip->isItemLocked()) transitionInfos.append(clip->info());
3464         }
3465     }
3466     if (clipInfos.count() > 0) {
3467         GroupClipsCommand *command = new GroupClipsCommand(this, clipInfos, transitionInfos, group);
3468         m_commandStack->push(command);
3469     }
3470 }
3471
3472 void CustomTrackView::doGroupClips(QList <ItemInfo> clipInfos, QList <ItemInfo> transitionInfos, bool group)
3473 {
3474     resetSelectionGroup();
3475     m_scene->clearSelection();
3476     if (!group) {
3477         for (int i = 0; i < clipInfos.count(); i++) {
3478             ClipItem *clip = getClipItemAt(clipInfos.at(i).startPos, clipInfos.at(i).track);
3479             if (clip == NULL) continue;
3480             if (clip->parentItem() && clip->parentItem()->type() == GROUPWIDGET) {
3481                 AbstractGroupItem *grp = static_cast <AbstractGroupItem *>(clip->parentItem());
3482                 m_document->clipManager()->removeGroup(grp);
3483                 scene()->destroyItemGroup(grp);
3484             }
3485             clip->setFlag(QGraphicsItem::ItemIsMovable, true);
3486         }
3487         for (int i = 0; i < transitionInfos.count(); i++) {
3488             Transition *tr = getTransitionItemAt(transitionInfos.at(i).startPos, transitionInfos.at(i).track);
3489             if (tr == NULL) continue;
3490             if (tr->parentItem() && tr->parentItem()->type() == GROUPWIDGET) {
3491                 AbstractGroupItem *grp = static_cast <AbstractGroupItem *>(tr->parentItem());
3492                 m_document->clipManager()->removeGroup(grp);
3493                 scene()->destroyItemGroup(grp);
3494             }
3495             tr->setFlag(QGraphicsItem::ItemIsMovable, true);
3496         }
3497         setDocumentModified();
3498         return;
3499     }
3500
3501     QList <QGraphicsItemGroup *> groups;
3502     for (int i = 0; i < clipInfos.count(); i++) {
3503         ClipItem *clip = getClipItemAt(clipInfos.at(i).startPos, clipInfos.at(i).track);
3504         if (clip) {
3505             clip->setSelected(true);
3506         }
3507     }
3508     for (int i = 0; i < transitionInfos.count(); i++) {
3509         Transition *clip = getTransitionItemAt(transitionInfos.at(i).startPos, transitionInfos.at(i).track);
3510         if (clip) {
3511             clip->setSelected(true);
3512         }
3513     }
3514
3515     groupSelectedItems(false, true);
3516     setDocumentModified();
3517 }
3518
3519 void CustomTrackView::addClip(QDomElement xml, const QString &clipId, ItemInfo info, EffectsList effects, bool refresh)
3520 {
3521     DocClipBase *baseclip = m_document->clipManager()->getClipById(clipId);
3522     if (baseclip == NULL) {
3523         emit displayMessage(i18n("No clip copied"), ErrorMessage);
3524         return;
3525     }
3526     ClipItem *item = new ClipItem(baseclip, info, m_document->fps(), xml.attribute("speed", "1").toDouble(), xml.attribute("strobe", "1").toInt());
3527     item->setEffectList(effects);
3528     if (xml.hasAttribute("audio_only")) item->setAudioOnly(true);
3529     else if (xml.hasAttribute("video_only")) item->setVideoOnly(true);
3530     scene()->addItem(item);
3531
3532     int tracknumber = m_document->tracksCount() - info.track - 1;
3533     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
3534     if (isLocked) item->setItemLocked(true);
3535
3536     baseclip->addReference();
3537     m_document->updateClip(baseclip->getId());
3538     info.track = m_document->tracksCount() - info.track;
3539     Mlt::Producer *prod;
3540     if (item->isAudioOnly()) prod = baseclip->audioProducer(info.track);
3541     else if (item->isVideoOnly()) prod = baseclip->videoProducer();
3542     else prod = baseclip->producer(info.track);
3543     m_document->renderer()->mltInsertClip(info, xml, prod);
3544     for (int i = 0; i < item->effectsCount(); i++) {
3545         m_document->renderer()->mltAddEffect(info.track, info.startPos, item->getEffectArgs(item->effectAt(i)), false);
3546     }
3547     setDocumentModified();
3548     if (refresh) m_document->renderer()->doRefresh();
3549     m_waitingThumbs.append(item);
3550     m_thumbsTimer.start();
3551 }
3552
3553 void CustomTrackView::slotUpdateClip(const QString &clipId, bool reload)
3554 {
3555     QList<QGraphicsItem *> list = scene()->items();
3556     ClipItem *clip = NULL;
3557     for (int i = 0; i < list.size(); ++i) {
3558         if (list.at(i)->type() == AVWIDGET) {
3559             clip = static_cast <ClipItem *>(list.at(i));
3560             if (clip->clipProducer() == clipId) {
3561                 ItemInfo info = clip->info();
3562                 info.track = m_document->tracksCount() - clip->track();
3563                 if (reload && !m_document->renderer()->mltUpdateClip(info, clip->xml(), clip->baseClip()->producer())) {
3564                     emit displayMessage(i18n("Cannot update clip (time: %1, track: %2)", info.startPos.frames(m_document->fps()), info.track), ErrorMessage);
3565                 }
3566                 clip->refreshClip(true);
3567                 clip->update();
3568             }
3569         }
3570     }
3571 }
3572
3573 ClipItem *CustomTrackView::getClipItemAtEnd(GenTime pos, int track)
3574 {
3575     int framepos = (int)(pos.frames(m_document->fps()));
3576     QList<QGraphicsItem *> list = scene()->items(QPointF(framepos - 1, track * m_tracksHeight + m_tracksHeight / 2));
3577     ClipItem *clip = NULL;
3578     for (int i = 0; i < list.size(); i++) {
3579         if (list.at(i)->type() == AVWIDGET) {
3580             ClipItem *test = static_cast <ClipItem *>(list.at(i));
3581             if (test->endPos() == pos) clip = test;
3582             break;
3583         }
3584     }
3585     return clip;
3586 }
3587
3588 ClipItem *CustomTrackView::getClipItemAtStart(GenTime pos, int track)
3589 {
3590     QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), track * m_tracksHeight + m_tracksHeight / 2));
3591     ClipItem *clip = NULL;
3592     for (int i = 0; i < list.size(); i++) {
3593         if (list.at(i)->type() == AVWIDGET) {
3594             ClipItem *test = static_cast <ClipItem *>(list.at(i));
3595             if (test->startPos() == pos) clip = test;
3596             break;
3597         }
3598     }
3599     return clip;
3600 }
3601
3602 ClipItem *CustomTrackView::getClipItemAt(int pos, int track)
3603 {
3604     const QPointF p(pos, track * m_tracksHeight + m_tracksHeight / 2);
3605     QList<QGraphicsItem *> list = scene()->items(p);
3606     ClipItem *clip = NULL;
3607     for (int i = 0; i < list.size(); i++) {
3608         if (list.at(i)->type() == AVWIDGET) {
3609             clip = static_cast <ClipItem *>(list.at(i));
3610             break;
3611         }
3612     }
3613     return clip;
3614 }
3615
3616 ClipItem *CustomTrackView::getClipItemAt(GenTime pos, int track)
3617 {
3618     return getClipItemAt((int) pos.frames(m_document->fps()), track);
3619 }
3620
3621 Transition *CustomTrackView::getTransitionItemAt(int pos, int track)
3622 {
3623     const QPointF p(pos, (track + 1) * m_tracksHeight);
3624     QList<QGraphicsItem *> list = scene()->items(p);
3625     Transition *clip = NULL;
3626     for (int i = 0; i < list.size(); i++) {
3627         if (list.at(i)->type() == TRANSITIONWIDGET) {
3628             clip = static_cast <Transition *>(list.at(i));
3629             break;
3630         }
3631     }
3632     return clip;
3633 }
3634
3635 Transition *CustomTrackView::getTransitionItemAt(GenTime pos, int track)
3636 {
3637     return getTransitionItemAt(pos.frames(m_document->fps()), track);
3638 }
3639
3640 Transition *CustomTrackView::getTransitionItemAtEnd(GenTime pos, int track)
3641 {
3642     int framepos = (int)(pos.frames(m_document->fps()));
3643     const QPointF p(framepos - 1, (track + 1) * m_tracksHeight);
3644     QList<QGraphicsItem *> list = scene()->items(p);
3645     Transition *clip = NULL;
3646     for (int i = 0; i < list.size(); i++) {
3647         if (list.at(i)->type() == TRANSITIONWIDGET) {
3648             Transition *test = static_cast <Transition *>(list.at(i));
3649             if (test->endPos() == pos) clip = test;
3650             break;
3651         }
3652     }
3653     return clip;
3654 }
3655
3656 Transition *CustomTrackView::getTransitionItemAtStart(GenTime pos, int track)
3657 {
3658     const QPointF p(pos.frames(m_document->fps()), (track + 1) * m_tracksHeight);
3659     QList<QGraphicsItem *> list = scene()->items(p);
3660     Transition *clip = NULL;
3661     for (int i = 0; i < list.size(); ++i) {
3662         if (list.at(i)->type() == TRANSITIONWIDGET) {
3663             Transition *test = static_cast <Transition *>(list.at(i));
3664             if (test->startPos() == pos) clip = test;
3665             break;
3666         }
3667     }
3668     return clip;
3669 }
3670
3671 void CustomTrackView::moveClip(const ItemInfo start, const ItemInfo end, bool refresh)
3672 {
3673     if (m_selectionGroup) resetSelectionGroup(false);
3674     ClipItem *item = getClipItemAt((int) start.startPos.frames(m_document->fps()), start.track);
3675     if (!item) {
3676         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);
3677         kDebug() << "----------------  ERROR, CANNOT find clip to move at.. ";
3678         return;
3679     }
3680     Mlt::Producer *prod;
3681     if (item->isAudioOnly()) prod = item->baseClip()->audioProducer(end.track);
3682     else if (item->isVideoOnly()) prod = item->baseClip()->videoProducer();
3683     else prod = item->baseClip()->producer(end.track);
3684
3685     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);
3686     if (success) {
3687         bool snap = KdenliveSettings::snaptopoints();
3688         KdenliveSettings::setSnaptopoints(false);
3689         item->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
3690
3691         int tracknumber = m_document->tracksCount() - end.track - 1;
3692         bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
3693         m_scene->clearSelection();
3694         if (isLocked) item->setItemLocked(true);
3695         else {
3696             if (item->isItemLocked()) item->setItemLocked(false);
3697             item->setSelected(true);
3698         }
3699         if (item->baseClip()->isTransparent()) {
3700             // Also move automatic transition
3701             Transition *tr = getTransitionItemAt(start.startPos, start.track);
3702             if (tr && tr->isAutomatic()) {
3703                 tr->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
3704                 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);
3705                 tr->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
3706             }
3707         }
3708         KdenliveSettings::setSnaptopoints(snap);
3709         setDocumentModified();
3710     } else {
3711         // undo last move and emit error message
3712         emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(end.startPos.frames(m_document->fps()))), ErrorMessage);
3713     }
3714     if (refresh) m_document->renderer()->doRefresh();
3715     //kDebug() << " // MOVED CLIP TO: " << end.startPos.frames(25) << ", ITEM START: " << item->startPos().frames(25);
3716 }
3717
3718 void CustomTrackView::moveGroup(QList <ItemInfo> startClip, QList <ItemInfo> startTransition, const GenTime offset, const int trackOffset, bool reverseMove)
3719 {
3720     // Group Items
3721     /*kDebug() << "//GRP MOVE, REVERS:" << reverseMove;
3722     kDebug() << "// GROUP MOV; OFFSET: " << offset.frames(25) << ", TK OFF: " << trackOffset;*/
3723     resetSelectionGroup();
3724     m_scene->clearSelection();
3725
3726     m_selectionGroup = new AbstractGroupItem(m_document->fps());
3727     scene()->addItem(m_selectionGroup);
3728
3729     m_document->renderer()->blockSignals(true);
3730     for (int i = 0; i < startClip.count(); i++) {
3731         if (reverseMove) {
3732             startClip[i].startPos = startClip.at(i).startPos - offset;
3733             startClip[i].track = startClip.at(i).track - trackOffset;
3734         }
3735         //kDebug()<<"//LKING FR CLIP AT:"<<startClip.at(i).startPos.frames(25)<<", TK:"<<startClip.at(i).track;
3736         ClipItem *clip = getClipItemAt(startClip.at(i).startPos, startClip.at(i).track);
3737         if (clip) {
3738             clip->setItemLocked(false);
3739             if (clip->parentItem()) {
3740                 m_selectionGroup->addToGroup(clip->parentItem());
3741                 clip->parentItem()->setFlag(QGraphicsItem::ItemIsMovable, false);
3742             } else {
3743                 m_selectionGroup->addToGroup(clip);
3744                 clip->setFlag(QGraphicsItem::ItemIsMovable, false);
3745             }
3746             m_document->renderer()->mltRemoveClip(m_document->tracksCount() - startClip.at(i).track, startClip.at(i).startPos);
3747         } else kDebug() << "//MISSING CLIP AT: " << startClip.at(i).startPos.frames(25);
3748     }
3749     for (int i = 0; i < startTransition.count(); i++) {
3750         if (reverseMove) {
3751             startTransition[i].startPos = startTransition.at(i).startPos - offset;
3752             startTransition[i].track = startTransition.at(i).track - trackOffset;
3753         }
3754         Transition *tr = getTransitionItemAt(startTransition.at(i).startPos, startTransition.at(i).track);
3755         if (tr) {
3756             tr->setItemLocked(false);
3757             if (tr->parentItem()) {
3758                 m_selectionGroup->addToGroup(tr->parentItem());
3759                 tr->parentItem()->setFlag(QGraphicsItem::ItemIsMovable, false);
3760             } else {
3761                 m_selectionGroup->addToGroup(tr);
3762                 tr->setFlag(QGraphicsItem::ItemIsMovable, false);
3763             }
3764             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());
3765         } else kDebug() << "//MISSING TRANSITION AT: " << startTransition.at(i).startPos.frames(25);
3766     }
3767     m_document->renderer()->blockSignals(false);
3768
3769     if (m_selectionGroup) {
3770         bool snap = KdenliveSettings::snaptopoints();
3771         KdenliveSettings::setSnaptopoints(false);
3772
3773         m_selectionGroup->translate(offset.frames(m_document->fps()), trackOffset *(qreal) m_tracksHeight);
3774         //m_selectionGroup->moveBy(offset.frames(m_document->fps()), trackOffset *(qreal) m_tracksHeight);
3775
3776         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
3777         // Expand groups
3778         int max = children.count();
3779         for (int i = 0; i < max; i++) {
3780             if (children.at(i)->type() == GROUPWIDGET) {
3781                 children += children.at(i)->childItems();
3782                 //AbstractGroupItem *grp = static_cast<AbstractGroupItem *>(children.at(i));
3783                 //grp->moveBy(offset.frames(m_document->fps()), trackOffset *(qreal) m_tracksHeight);
3784                 /*m_document->clipManager()->removeGroup(grp);
3785                 m_scene->destroyItemGroup(grp);*/
3786                 children.removeAll(children.at(i));
3787                 i--;
3788             }
3789         }
3790
3791         for (int i = 0; i < children.count(); i++) {
3792             // re-add items in correct place
3793             if (children.at(i)->type() != AVWIDGET && children.at(i)->type() != TRANSITIONWIDGET) continue;
3794             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
3795             item->updateItem();
3796             ItemInfo info = item->info();
3797             int tracknumber = m_document->tracksCount() - info.track - 1;
3798             bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
3799             if (isLocked) item->setItemLocked(true);
3800             else if (item->isItemLocked()) item->setItemLocked(false);
3801
3802             if (item->type() == AVWIDGET) {
3803                 ClipItem *clip = static_cast <ClipItem*>(item);
3804                 info.track = m_document->tracksCount() - info.track;
3805                 Mlt::Producer *prod;
3806                 if (clip->isAudioOnly()) prod = clip->baseClip()->audioProducer(info.track);
3807                 else if (clip->isVideoOnly()) prod = clip->baseClip()->videoProducer();
3808                 else prod = clip->baseClip()->producer(info.track);
3809                 m_document->renderer()->mltInsertClip(info, clip->xml(), prod);
3810             } else if (item->type() == TRANSITIONWIDGET) {
3811                 Transition *tr = static_cast <Transition*>(item);
3812                 int newTrack;
3813                 if (!tr->forcedTrack()) newTrack = getPreviousVideoTrack(info.track);
3814                 else {
3815                     newTrack = tr->transitionEndTrack() + trackOffset;
3816                     if (newTrack < 0 || newTrack > m_document->tracksCount()) newTrack = getPreviousVideoTrack(info.track);
3817                 }
3818                 tr->updateTransitionEndTrack(newTrack);
3819                 m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
3820             }
3821         }
3822         resetSelectionGroup(false);
3823         KdenliveSettings::setSnaptopoints(snap);
3824         m_document->renderer()->doRefresh();
3825     } else kDebug() << "///////// WARNING; NO GROUP TO MOVE";
3826 }
3827
3828 void CustomTrackView::moveTransition(const ItemInfo start, const ItemInfo end, bool m_refresh)
3829 {
3830     Transition *item = getTransitionItemAt(start.startPos, start.track);
3831     if (!item) {
3832         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);
3833         kDebug() << "----------------  ERROR, CANNOT find transition to move... ";// << startPos.x() * m_scale * FRAME_SIZE + 1 << ", " << startPos.y() * m_tracksHeight + m_tracksHeight / 2;
3834         return;
3835     }
3836     //kDebug() << "----------------  Move TRANSITION FROM: " << startPos.x() << ", END:" << endPos.x() << ",TRACKS: " << oldtrack << " TO " << newtrack;
3837     bool snap = KdenliveSettings::snaptopoints();
3838     KdenliveSettings::setSnaptopoints(false);
3839     //kDebug()<<"///  RESIZE TRANS START: ("<< startPos.x()<<"x"<< startPos.y()<<") / ("<<endPos.x()<<"x"<< endPos.y()<<")";
3840     if (end.endPos - end.startPos == start.endPos - start.startPos) {
3841         // Transition was moved
3842         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
3843     } else if (end.endPos == start.endPos) {
3844         // Transition start resize
3845         item->resizeStart((int) end.startPos.frames(m_document->fps()));
3846     } else if (end.startPos == start.startPos) {
3847         // Transition end resize;
3848         kDebug() << "// resize END: " << end.endPos.frames(m_document->fps());
3849         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
3850     } else {
3851         // Move & resize
3852         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
3853         item->resizeStart((int) end.startPos.frames(m_document->fps()));
3854         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
3855     }
3856     //item->moveTransition(GenTime((int) (endPos.x() - startPos.x()), m_document->fps()));
3857     KdenliveSettings::setSnaptopoints(snap);
3858     item->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
3859     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);
3860     if (m_dragItem && m_dragItem == item) {
3861         QPoint p;
3862         ClipItem *transitionClip = getClipItemAt(item->startPos(), item->track());
3863         if (transitionClip && transitionClip->baseClip()) {
3864             QString size = transitionClip->baseClip()->getProperty("frame_size");
3865             double factor = transitionClip->baseClip()->getProperty("aspect_ratio").toDouble();
3866             p.setX((int)(size.section('x', 0, 0).toInt() * factor + 0.5));
3867             p.setY(size.section('x', 1, 1).toInt());
3868         }
3869         emit transitionItemSelected(item, getPreviousVideoTrack(item->track()), p);
3870     }
3871     if (m_refresh) m_document->renderer()->doRefresh();
3872     setDocumentModified();
3873 }
3874
3875 void CustomTrackView::resizeClip(const ItemInfo start, const ItemInfo end, bool dontWorry)
3876 {
3877     bool resizeClipStart = (start.startPos != end.startPos);
3878     ClipItem *item = getClipItemAtStart(start.startPos, start.track);
3879     if (!item) {
3880         if (dontWorry) return;
3881         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);
3882         kDebug() << "----------------  ERROR, CANNOT find clip to resize at... "; // << startPos;
3883         return;
3884     }
3885     if (item->parentItem()) {
3886         // Item is part of a group, reset group
3887         resetSelectionGroup();
3888     }
3889
3890     bool snap = KdenliveSettings::snaptopoints();
3891     KdenliveSettings::setSnaptopoints(false);
3892     if (resizeClipStart) {
3893         ItemInfo clipinfo = item->info();
3894         clipinfo.track = m_document->tracksCount() - clipinfo.track;
3895         bool success = m_document->renderer()->mltResizeClipStart(clipinfo, end.startPos - clipinfo.startPos);
3896         if (success) {
3897             kDebug() << "RESIZE CLP STRAT TO:" << end.startPos.frames(m_document->fps()) << ", OLD ST: " << start.startPos.frames(25);
3898             item->resizeStart((int) end.startPos.frames(m_document->fps()));
3899             updatePositionEffects(item, clipinfo);
3900         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
3901     } else {
3902         ItemInfo clipinfo = item->info();
3903         clipinfo.track = m_document->tracksCount() - clipinfo.track;
3904         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, end.endPos - clipinfo.startPos);
3905         if (success) {
3906             item->resizeEnd((int) end.endPos.frames(m_document->fps()));
3907             updatePositionEffects(item, clipinfo);
3908         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
3909     }
3910     if (!resizeClipStart && end.cropStart != start.cropStart) {
3911         kDebug() << "// RESIZE CROP, DIFF: " << (end.cropStart - start.cropStart).frames(25);
3912         ItemInfo clipinfo = end;
3913         clipinfo.track = m_document->tracksCount() - end.track;
3914         bool success = m_document->renderer()->mltResizeClipCrop(clipinfo, end.cropStart - start.cropStart);
3915         if (success) {
3916             item->setCropStart(end.cropStart);
3917             item->resetThumbs(true);
3918         }
3919     }
3920     m_document->renderer()->doRefresh();
3921     KdenliveSettings::setSnaptopoints(snap);
3922     setDocumentModified();
3923 }
3924
3925 void CustomTrackView::updatePositionEffects(ClipItem * item, ItemInfo info)
3926 {
3927     int end = item->fadeIn();
3928     if (end != 0) {
3929         // there is a fade in effect
3930         int effectPos = item->hasEffect("volume", "fadein");
3931         if (effectPos != -1) {
3932             QDomElement oldeffect = item->effectAt(effectPos);
3933             int start = item->cropStart().frames(m_document->fps());
3934             int max = item->cropDuration().frames(m_document->fps());
3935             if (end > max) {
3936                 // Make sure the fade effect is not longer than the clip
3937                 item->setFadeIn(max);
3938                 end = item->fadeIn();
3939             }
3940             end += start;
3941             EffectsList::setParameter(oldeffect, "in", QString::number(start));
3942             EffectsList::setParameter(oldeffect, "out", QString::number(end));
3943             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3944                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3945             // if fade effect is displayed, update the effect edit widget with new clip duration
3946             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3947         }
3948         effectPos = item->hasEffect("brightness", "fade_from_black");
3949         if (effectPos != -1) {
3950             QDomElement oldeffect = item->effectAt(effectPos);
3951             int start = item->cropStart().frames(m_document->fps());
3952             int max = item->cropDuration().frames(m_document->fps());
3953             if (end > max) {
3954                 // Make sure the fade effect is not longer than the clip
3955                 item->setFadeIn(max);
3956                 end = item->fadeIn();
3957             }
3958             end += start;
3959             EffectsList::setParameter(oldeffect, "in", QString::number(start));
3960             EffectsList::setParameter(oldeffect, "out", QString::number(end));
3961             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3962                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3963             // if fade effect is displayed, update the effect edit widget with new clip duration
3964             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3965         }
3966     }
3967     int start = item->fadeOut();
3968     if (start != 0) {
3969         // there is a fade out effect
3970         int effectPos = item->hasEffect("volume", "fadeout");
3971         if (effectPos != -1) {
3972             QDomElement oldeffect = item->effectAt(effectPos);
3973             int max = item->cropDuration().frames(m_document->fps());
3974             int end = max + item->cropStart().frames(m_document->fps());
3975             if (start > max) {
3976                 // Make sure the fade effect is not longer than the clip
3977                 item->setFadeOut(max);
3978                 start = item->fadeOut();
3979             }
3980             start = end - start;
3981             EffectsList::setParameter(oldeffect, "in", QString::number(start));
3982             EffectsList::setParameter(oldeffect, "out", QString::number(end));
3983             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3984                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3985             // if fade effect is displayed, update the effect edit widget with new clip duration
3986             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3987         }
3988         effectPos = item->hasEffect("brightness", "fade_to_black");
3989         if (effectPos != -1) {
3990             QDomElement oldeffect = item->effectAt(effectPos);
3991             int max = item->cropDuration().frames(m_document->fps());
3992             int end = max + item->cropStart().frames(m_document->fps());
3993             if (start > max) {
3994                 // Make sure the fade effect is not longer than the clip
3995                 item->setFadeOut(max);
3996                 start = item->fadeOut();
3997             }
3998             start = end - start;
3999             EffectsList::setParameter(oldeffect, "in", QString::number(start));
4000             EffectsList::setParameter(oldeffect, "out", QString::number(end));
4001             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
4002                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
4003             // if fade effect is displayed, update the effect edit widget with new clip duration
4004             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
4005         }
4006     }
4007
4008     int effectPos = item->hasEffect("freeze", "freeze");
4009     if (effectPos != -1) {
4010         // Freeze effect needs to be adjusted with clip resize
4011         int diff = (info.startPos - item->startPos()).frames(m_document->fps());
4012         QDomElement eff = item->getEffectAt(effectPos);
4013         if (!eff.isNull() && diff != 0) {
4014             int freeze_pos = EffectsList::parameter(eff, "frame").toInt() + diff;
4015             EffectsList::setParameter(eff, "frame", QString::number(freeze_pos));
4016             if (item->isSelected() && item->selectedEffect().attribute("id") == "freeze") {
4017                 emit clipItemSelected(item, item->selectedEffectIndex());
4018             }
4019         }
4020     }
4021 }
4022
4023 double CustomTrackView::getSnapPointForPos(double pos)
4024 {
4025     return m_scene->getSnapPointForPos(pos, KdenliveSettings::snaptopoints());
4026 }
4027
4028 void CustomTrackView::updateSnapPoints(AbstractClipItem *selected, QList <GenTime> offsetList, bool skipSelectedItems)
4029 {
4030     QList <GenTime> snaps;
4031     if (selected && offsetList.isEmpty()) offsetList.append(selected->cropDuration());
4032     QList<QGraphicsItem *> itemList = items();
4033     for (int i = 0; i < itemList.count(); i++) {
4034         if (itemList.at(i) == selected) continue;
4035         if (skipSelectedItems && itemList.at(i)->isSelected()) continue;
4036         if (itemList.at(i)->type() == AVWIDGET) {
4037             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
4038             GenTime start = item->startPos();
4039             GenTime end = item->endPos();
4040             snaps.append(start);
4041             snaps.append(end);
4042             if (!offsetList.isEmpty()) {
4043                 for (int j = 0; j < offsetList.size(); j++) {
4044                     if (start > offsetList.at(j)) snaps.append(start - offsetList.at(j));
4045                     if (end > offsetList.at(j)) snaps.append(end - offsetList.at(j));
4046                 }
4047             }
4048             // Add clip markers
4049             QList < GenTime > markers = item->snapMarkers();
4050             for (int j = 0; j < markers.size(); ++j) {
4051                 GenTime t = markers.at(j);
4052                 snaps.append(t);
4053                 if (!offsetList.isEmpty()) {
4054                     for (int k = 0; k < offsetList.size(); k++) {
4055                         if (t > offsetList.at(k)) snaps.append(t - offsetList.at(k));
4056                     }
4057                 }
4058             }
4059         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
4060             Transition *transition = static_cast <Transition*>(itemList.at(i));
4061             GenTime start = transition->startPos();
4062             GenTime end = transition->endPos();
4063             snaps.append(start);
4064             snaps.append(end);
4065             if (!offsetList.isEmpty()) {
4066                 for (int j = 0; j < offsetList.size(); j++) {
4067                     if (start > offsetList.at(j)) snaps.append(start - offsetList.at(j));
4068                     if (end > offsetList.at(j)) snaps.append(end - offsetList.at(j));
4069                 }
4070             }
4071         }
4072     }
4073
4074     // add cursor position
4075     GenTime pos = GenTime(m_cursorPos, m_document->fps());
4076     snaps.append(pos);
4077     if (!offsetList.isEmpty()) {
4078         for (int j = 0; j < offsetList.size(); j++) {
4079             snaps.append(pos - offsetList.at(j));
4080         }
4081     }
4082
4083     // add guides
4084     for (int i = 0; i < m_guides.count(); i++) {
4085         snaps.append(m_guides.at(i)->position());
4086         if (!offsetList.isEmpty()) {
4087             for (int j = 0; j < offsetList.size(); j++) {
4088                 snaps.append(m_guides.at(i)->position() - offsetList.at(j));
4089             }
4090         }
4091     }
4092
4093     qSort(snaps);
4094     m_scene->setSnapList(snaps);
4095     //for (int i = 0; i < m_snapPoints.size(); ++i)
4096     //    kDebug() << "SNAP POINT: " << m_snapPoints.at(i).frames(25);
4097 }
4098
4099 void CustomTrackView::slotSeekToPreviousSnap()
4100 {
4101     updateSnapPoints(NULL);
4102     GenTime res = m_scene->previousSnapPoint(GenTime(m_cursorPos, m_document->fps()));
4103     setCursorPos((int) res.frames(m_document->fps()));
4104     checkScrolling();
4105 }
4106
4107 void CustomTrackView::slotSeekToNextSnap()
4108 {
4109     updateSnapPoints(NULL);
4110     GenTime res = m_scene->nextSnapPoint(GenTime(m_cursorPos, m_document->fps()));
4111     setCursorPos((int) res.frames(m_document->fps()));
4112     checkScrolling();
4113 }
4114
4115 void CustomTrackView::clipStart()
4116 {
4117     AbstractClipItem *item = getMainActiveClip();
4118     if (item != NULL) {
4119         setCursorPos((int) item->startPos().frames(m_document->fps()));
4120         checkScrolling();
4121     }
4122 }
4123
4124 void CustomTrackView::clipEnd()
4125 {
4126     AbstractClipItem *item = getMainActiveClip();
4127     if (item != NULL) {
4128         setCursorPos((int) item->endPos().frames(m_document->fps()) - 1);
4129         checkScrolling();
4130     }
4131 }
4132
4133 void CustomTrackView::slotAddClipMarker(const QString &id, GenTime t, QString c)
4134 {
4135     QString oldcomment = m_document->clipManager()->getClipById(id)->markerComment(t);
4136     AddMarkerCommand *command = new AddMarkerCommand(this, oldcomment, c, id, t);
4137     m_commandStack->push(command);
4138 }
4139
4140 void CustomTrackView::slotDeleteClipMarker(const QString &comment, const QString &id, const GenTime &position)
4141 {
4142     AddMarkerCommand *command = new AddMarkerCommand(this, comment, QString(), id, position);
4143     m_commandStack->push(command);
4144 }
4145
4146 void CustomTrackView::slotDeleteAllClipMarkers(const QString &id)
4147 {
4148     DocClipBase *base = m_document->clipManager()->getClipById(id);
4149     QList <CommentedTime> markers = base->commentedSnapMarkers();
4150
4151     if (markers.isEmpty()) {
4152         emit displayMessage(i18n("Clip has no markers"), ErrorMessage);
4153         return;
4154     }
4155     QUndoCommand *deleteMarkers = new QUndoCommand();
4156     deleteMarkers->setText("Delete clip markers");
4157
4158     for (int i = 0; i < markers.size(); i++) {
4159         new AddMarkerCommand(this, markers.at(i).comment(), QString(), id, markers.at(i).time(), deleteMarkers);
4160     }
4161     m_commandStack->push(deleteMarkers);
4162 }
4163
4164 void CustomTrackView::addMarker(const QString &id, const GenTime &pos, const QString comment)
4165 {
4166     DocClipBase *base = m_document->clipManager()->getClipById(id);
4167     if (!comment.isEmpty()) base->addSnapMarker(pos, comment);
4168     else base->deleteSnapMarker(pos);
4169     emit updateClipMarkers(base);
4170     setDocumentModified();
4171     viewport()->update();
4172 }
4173
4174 int CustomTrackView::hasGuide(int pos, int offset)
4175 {
4176     for (int i = 0; i < m_guides.count(); i++) {
4177         int guidePos = m_guides.at(i)->position().frames(m_document->fps());
4178         if (qAbs(guidePos - pos) <= offset) return guidePos;
4179         else if (guidePos > pos) return -1;
4180     }
4181     return -1;
4182 }
4183
4184 void CustomTrackView::editGuide(const GenTime oldPos, const GenTime pos, const QString &comment)
4185 {
4186     if (oldPos > GenTime() && pos > GenTime()) {
4187         // move guide
4188         for (int i = 0; i < m_guides.count(); i++) {
4189             if (m_guides.at(i)->position() == oldPos) {
4190                 Guide *item = m_guides.at(i);
4191                 item->updateGuide(pos, comment);
4192                 break;
4193             }
4194         }
4195     } else if (pos > GenTime()) addGuide(pos, comment);
4196     else {
4197         // remove guide
4198         bool found = false;
4199         for (int i = 0; i < m_guides.count(); i++) {
4200             if (m_guides.at(i)->position() == oldPos) {
4201                 delete m_guides.takeAt(i);
4202                 found = true;
4203                 break;
4204             }
4205         }
4206         if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
4207     }
4208     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
4209     m_document->syncGuides(m_guides);
4210 }
4211
4212 bool CustomTrackView::addGuide(const GenTime pos, const QString &comment)
4213 {
4214     for (int i = 0; i < m_guides.count(); i++) {
4215         if (m_guides.at(i)->position() == pos) {
4216             emit displayMessage(i18n("A guide already exists at position %1", m_document->timecode().getTimecodeFromFrames(pos.frames(m_document->fps()))), ErrorMessage);
4217             return false;
4218         }
4219     }
4220     Guide *g = new Guide(this, pos, comment, m_tracksHeight * m_document->tracksCount());
4221     scene()->addItem(g);
4222     m_guides.append(g);
4223     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
4224     m_document->syncGuides(m_guides);
4225     return true;
4226 }
4227
4228 void CustomTrackView::slotAddGuide()
4229 {
4230     CommentedTime marker(GenTime(m_cursorPos, m_document->fps()), i18n("Guide"));
4231     MarkerDialog d(NULL, marker, m_document->timecode(), i18n("Add Guide"), this);
4232     if (d.exec() != QDialog::Accepted) return;
4233     if (addGuide(d.newMarker().time(), d.newMarker().comment())) {
4234         EditGuideCommand *command = new EditGuideCommand(this, GenTime(), QString(), d.newMarker().time(), d.newMarker().comment(), false);
4235         m_commandStack->push(command);
4236     }
4237 }
4238
4239 void CustomTrackView::slotEditGuide(int guidePos)
4240 {
4241     GenTime pos;
4242     if (guidePos == -1) pos = GenTime(m_cursorPos, m_document->fps());
4243     else pos = GenTime(guidePos, m_document->fps());
4244     bool found = false;
4245     for (int i = 0; i < m_guides.count(); i++) {
4246         if (m_guides.at(i)->position() == pos) {
4247             slotEditGuide(m_guides.at(i)->info());
4248             found = true;
4249             break;
4250         }
4251     }
4252     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
4253 }
4254
4255 void CustomTrackView::slotEditGuide(CommentedTime guide)
4256 {
4257     MarkerDialog d(NULL, guide, m_document->timecode(), i18n("Edit Guide"), this);
4258     if (d.exec() == QDialog::Accepted) {
4259         EditGuideCommand *command = new EditGuideCommand(this, guide.time(), guide.comment(), d.newMarker().time(), d.newMarker().comment(), true);
4260         m_commandStack->push(command);
4261     }
4262 }
4263
4264
4265 void CustomTrackView::slotEditTimeLineGuide()
4266 {
4267     if (m_dragGuide == NULL) return;
4268     CommentedTime guide = m_dragGuide->info();
4269     MarkerDialog d(NULL, guide, m_document->timecode(), i18n("Edit Guide"), this);
4270     if (d.exec() == QDialog::Accepted) {
4271         EditGuideCommand *command = new EditGuideCommand(this, guide.time(), guide.comment(), d.newMarker().time(), d.newMarker().comment(), true);
4272         m_commandStack->push(command);
4273     }
4274 }
4275
4276 void CustomTrackView::slotDeleteGuide(int guidePos)
4277 {
4278     GenTime pos;
4279     if (guidePos == -1) pos = GenTime(m_cursorPos, m_document->fps());
4280     else pos = GenTime(guidePos, m_document->fps());
4281     bool found = false;
4282     for (int i = 0; i < m_guides.count(); i++) {
4283         if (m_guides.at(i)->position() == pos) {
4284             EditGuideCommand *command = new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true);
4285             m_commandStack->push(command);
4286             found = true;
4287             break;
4288         }
4289     }
4290     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
4291 }
4292
4293
4294 void CustomTrackView::slotDeleteTimeLineGuide()
4295 {
4296     if (m_dragGuide == NULL) return;
4297     EditGuideCommand *command = new EditGuideCommand(this, m_dragGuide->position(), m_dragGuide->label(), GenTime(), QString(), true);
4298     m_commandStack->push(command);
4299 }
4300
4301
4302 void CustomTrackView::slotDeleteAllGuides()
4303 {
4304     QUndoCommand *deleteAll = new QUndoCommand();
4305     deleteAll->setText("Delete all guides");
4306     for (int i = 0; i < m_guides.count(); i++) {
4307         new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true, deleteAll);
4308     }
4309     m_commandStack->push(deleteAll);
4310 }
4311
4312 void CustomTrackView::setTool(PROJECTTOOL tool)
4313 {
4314     m_tool = tool;
4315 }
4316
4317 void CustomTrackView::setScale(double scaleFactor, double verticalScale)
4318 {
4319     QMatrix matrix;
4320     matrix = matrix.scale(scaleFactor, verticalScale);
4321     m_scene->setScale(scaleFactor, verticalScale);
4322     if (m_visualTip) {
4323         scene()->removeItem(m_visualTip);
4324         m_animationTimer->stop();
4325         delete m_animation;
4326         m_animation = NULL;
4327         delete m_visualTip;
4328         m_visualTip = NULL;
4329     }
4330     double verticalPos = mapToScene(QPoint(0, viewport()->height() / 2)).y();
4331     setMatrix(matrix);
4332     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), m_tracksHeight * m_document->tracksCount() * verticalScale);
4333     int diff = sceneRect().width() - m_projectDuration;
4334     if (diff * matrix.m11() < 50) {
4335         if (matrix.m11() < 0.4) setSceneRect(0, 0, (m_projectDuration + 100 / matrix.m11()), sceneRect().height());
4336         else setSceneRect(0, 0, (m_projectDuration + 300), sceneRect().height());
4337     }
4338     centerOn(QPointF(cursorPos(), verticalPos));
4339 }
4340
4341 void CustomTrackView::slotRefreshGuides()
4342 {
4343     if (KdenliveSettings::showmarkers()) {
4344         for (int i = 0; i < m_guides.count(); i++) {
4345             m_guides.at(i)->update();
4346         }
4347     }
4348 }
4349
4350 void CustomTrackView::drawBackground(QPainter * painter, const QRectF &rect)
4351 {
4352     //kDebug() << "// DRAW BG: " << rect.width();
4353     painter->setClipRect(rect);
4354     KColorScheme scheme(palette().currentColorGroup(), KColorScheme::Window);
4355     QPen pen1 = painter->pen();
4356     pen1.setColor(scheme.shade(KColorScheme::DarkShade));
4357     painter->setPen(pen1);
4358     double min = rect.left();
4359     double max = rect.right();
4360     painter->drawLine(QPointF(min, 0), QPointF(max, 0));
4361     int maxTrack = m_document->tracksCount();
4362     QColor lockedColor = scheme.background(KColorScheme::NegativeBackground).color();
4363     QColor audioColor = palette().alternateBase().color();
4364     QColor base = scheme.background(KColorScheme::NormalBackground).color();
4365     for (int i = 0; i < maxTrack; i++) {
4366         TrackInfo info = m_document->trackInfoAt(maxTrack - i - 1);
4367         if (info.isLocked || info.type == AUDIOTRACK || i == m_selectedTrack) {
4368             const QRectF track(min, m_tracksHeight * i + 1, max - min, m_tracksHeight - 1);
4369             if (i == m_selectedTrack) painter->fillRect(track, scheme.background(KColorScheme::ActiveBackground).color());
4370             else painter->fillRect(track, info.isLocked ? lockedColor : audioColor);
4371         }
4372         painter->drawLine(QPointF(min, m_tracksHeight *(i + 1)), QPointF(max, m_tracksHeight *(i + 1)));
4373     }
4374     int lowerLimit = m_tracksHeight * maxTrack + 1;
4375     if (height() > lowerLimit) {
4376         const QRectF bg(min, lowerLimit, max - min, height() - lowerLimit);
4377         painter->fillRect(bg, base);
4378     }
4379 }
4380
4381 bool CustomTrackView::findString(const QString &text)
4382 {
4383     QString marker;
4384     for (int i = 0; i < m_searchPoints.size(); ++i) {
4385         marker = m_searchPoints.at(i).comment();
4386         if (marker.contains(text, Qt::CaseInsensitive)) {
4387             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
4388             int vert = verticalScrollBar()->value();
4389             int hor = cursorPos();
4390             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
4391             m_findIndex = i;
4392             return true;
4393         }
4394     }
4395     return false;
4396 }
4397
4398 bool CustomTrackView::findNextString(const QString &text)
4399 {
4400     QString marker;
4401     for (int i = m_findIndex + 1; i < m_searchPoints.size(); ++i) {
4402         marker = m_searchPoints.at(i).comment();
4403         if (marker.contains(text, Qt::CaseInsensitive)) {
4404             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
4405             int vert = verticalScrollBar()->value();
4406             int hor = cursorPos();
4407             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
4408             m_findIndex = i;
4409             return true;
4410         }
4411     }
4412     m_findIndex = -1;
4413     return false;
4414 }
4415
4416 void CustomTrackView::initSearchStrings()
4417 {
4418     m_searchPoints.clear();
4419     QList<QGraphicsItem *> itemList = items();
4420     for (int i = 0; i < itemList.count(); i++) {
4421         // parse all clip names
4422         if (itemList.at(i)->type() == AVWIDGET) {
4423             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
4424             GenTime start = item->startPos();
4425             CommentedTime t(start, item->clipName());
4426             m_searchPoints.append(t);
4427             // add all clip markers
4428             QList < CommentedTime > markers = item->commentedSnapMarkers();
4429             m_searchPoints += markers;
4430         }
4431     }
4432
4433     // add guides
4434     for (int i = 0; i < m_guides.count(); i++) {
4435         m_searchPoints.append(m_guides.at(i)->info());
4436     }
4437
4438     qSort(m_searchPoints);
4439 }
4440
4441 void CustomTrackView::clearSearchStrings()
4442 {
4443     m_searchPoints.clear();
4444     m_findIndex = 0;
4445 }
4446
4447 void CustomTrackView::copyClip()
4448 {
4449     qDeleteAll(m_copiedItems);
4450     m_copiedItems.clear();
4451     QList<QGraphicsItem *> itemList = scene()->selectedItems();
4452     if (itemList.count() == 0) {
4453         emit displayMessage(i18n("Select a clip before copying"), ErrorMessage);
4454         return;
4455     }
4456     for (int i = 0; i < itemList.count(); i++) {
4457         if (itemList.at(i)->type() == AVWIDGET) {
4458             ClipItem *clip = static_cast <ClipItem *>(itemList.at(i));
4459             ClipItem *clone = clip->clone(clip->info());
4460             m_copiedItems.append(clone);
4461         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
4462             Transition *dup = static_cast <Transition *>(itemList.at(i));
4463             m_copiedItems.append(dup->clone());
4464         }
4465     }
4466 }
4467
4468 bool CustomTrackView::canBePastedTo(ItemInfo info, int type) const
4469 {
4470     if (m_scene->editMode() != NORMALEDIT) {
4471         // If we are in overwrite mode, always allow the move
4472         return true;
4473     }
4474     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));
4475     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
4476     for (int i = 0; i < collisions.count(); i++) {
4477         if (collisions.at(i)->type() == type) return false;
4478     }
4479     return true;
4480 }
4481
4482 bool CustomTrackView::canBePastedTo(QList <ItemInfo> infoList, int type) const
4483 {
4484     QPainterPath path;
4485     for (int i = 0; i < infoList.count(); i++) {
4486         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));
4487         path.addRect(rect);
4488     }
4489     QList<QGraphicsItem *> collisions = scene()->items(path);
4490     for (int i = 0; i < collisions.count(); i++) {
4491         if (collisions.at(i)->type() == type) return false;
4492     }
4493     return true;
4494 }
4495
4496 bool CustomTrackView::canBePasted(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const
4497 {
4498     for (int i = 0; i < items.count(); i++) {
4499         ItemInfo info = items.at(i)->info();
4500         info.startPos += offset;
4501         info.endPos += offset;
4502         info.track += trackOffset;
4503         if (!canBePastedTo(info, items.at(i)->type())) return false;
4504     }
4505     return true;
4506 }
4507
4508 bool CustomTrackView::canBeMoved(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const
4509 {
4510     QPainterPath movePath;
4511     movePath.moveTo(0, 0);
4512
4513     for (int i = 0; i < items.count(); i++) {
4514         ItemInfo info = items.at(i)->info();
4515         info.startPos = info.startPos + offset;
4516         info.endPos = info.endPos + offset;
4517         info.track = info.track + trackOffset;
4518         if (info.startPos < GenTime()) {
4519             // No clip should go below 0
4520             return false;
4521         }
4522         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));
4523         movePath.addRect(rect);
4524     }
4525     QList<QGraphicsItem *> collisions = scene()->items(movePath, Qt::IntersectsItemBoundingRect);
4526     for (int i = 0; i < collisions.count(); i++) {
4527         if ((collisions.at(i)->type() == AVWIDGET || collisions.at(i)->type() == TRANSITIONWIDGET) && !items.contains(static_cast <AbstractClipItem *>(collisions.at(i)))) {
4528             kDebug() << "  ////////////   CLIP COLLISION, MOVE NOT ALLOWED";
4529             return false;
4530         }
4531     }
4532     return true;
4533 }
4534
4535 void CustomTrackView::pasteClip()
4536 {
4537     if (m_copiedItems.count() == 0) {
4538         emit displayMessage(i18n("No clip copied"), ErrorMessage);
4539         return;
4540     }
4541     QPoint position;
4542     if (m_menuPosition.isNull()) {
4543         position = mapFromGlobal(QCursor::pos());
4544         if (!underMouse() || position.y() > m_tracksHeight * m_document->tracksCount()) {
4545             emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
4546             return;
4547         }
4548     } else position = m_menuPosition;
4549     GenTime pos = GenTime((int)(mapToScene(position).x()), m_document->fps());
4550     int track = (int)(position.y() / m_tracksHeight);
4551     ItemInfo first = m_copiedItems.at(0)->info();
4552
4553     GenTime offset = pos - first.startPos;
4554     int trackOffset = track - first.track;
4555
4556     if (!canBePasted(m_copiedItems, offset, trackOffset)) {
4557         emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
4558         return;
4559     }
4560     QUndoCommand *pasteClips = new QUndoCommand();
4561     pasteClips->setText("Paste clips");
4562
4563     for (int i = 0; i < m_copiedItems.count(); i++) {
4564         // parse all clip names
4565         if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == AVWIDGET) {
4566             ClipItem *clip = static_cast <ClipItem *>(m_copiedItems.at(i));
4567             ItemInfo info = clip->info();
4568             info.startPos += offset;
4569             info.endPos += offset;
4570             info.track += trackOffset;
4571             if (canBePastedTo(info, AVWIDGET)) {
4572                 new AddTimelineClipCommand(this, clip->xml(), clip->clipProducer(), info, clip->effectList(), true, false, pasteClips);
4573             } else emit displayMessage(i18n("Cannot paste clip to selected place"), ErrorMessage);
4574         } else if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == TRANSITIONWIDGET) {
4575             Transition *tr = static_cast <Transition *>(m_copiedItems.at(i));
4576             ItemInfo info;
4577             info.startPos = tr->startPos() + offset;
4578             info.endPos = tr->endPos() + offset;
4579             info.track = tr->track() + trackOffset;
4580             int transitionEndTrack;
4581             if (!tr->forcedTrack()) transitionEndTrack = getPreviousVideoTrack(info.track);
4582             else transitionEndTrack = tr->transitionEndTrack();
4583             if (canBePastedTo(info, TRANSITIONWIDGET)) {
4584                 if (info.startPos >= info.endPos) {
4585                     emit displayMessage(i18n("Invalid transition"), ErrorMessage);
4586                 } else new AddTransitionCommand(this, info, transitionEndTrack, tr->toXML(), false, true, pasteClips);
4587             } else emit displayMessage(i18n("Cannot paste transition to selected place"), ErrorMessage);
4588         }
4589     }
4590     m_commandStack->push(pasteClips);
4591 }
4592
4593 void CustomTrackView::pasteClipEffects()
4594 {
4595     if (m_copiedItems.count() != 1 || m_copiedItems.at(0)->type() != AVWIDGET) {
4596         emit displayMessage(i18n("You must copy exactly one clip before pasting effects"), ErrorMessage);
4597         return;
4598     }
4599     ClipItem *clip = static_cast < ClipItem *>(m_copiedItems.at(0));
4600
4601     QUndoCommand *paste = new QUndoCommand();
4602     paste->setText("Paste effects");
4603
4604     QList<QGraphicsItem *> clips = scene()->selectedItems();
4605     for (int i = 0; i < clips.count(); ++i) {
4606         if (clips.at(i)->type() == AVWIDGET) {
4607             ClipItem *item = static_cast < ClipItem *>(clips.at(i));
4608             for (int j = 0; j < clip->effectsCount(); j++) {
4609                 QDomElement eff = clip->effectAt(j);
4610                 if (eff.attribute("unique", "0") == "0" || item->hasEffect(eff.attribute("tag"), eff.attribute("id")) == -1) {
4611                     new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), eff, true, paste);
4612                 }
4613             }
4614         }
4615     }
4616     m_commandStack->push(paste);
4617
4618     // adjust effects (fades, ...)
4619     for (int i = 0; i < clips.count(); ++i) {
4620         ClipItem *item = static_cast < ClipItem *>(clips.at(i));
4621         updatePositionEffects(item, item->info());
4622     }
4623 }
4624
4625
4626 ClipItem *CustomTrackView::getClipUnderCursor() const
4627 {
4628     QRectF rect((double) m_cursorPos, 0.0, 1.0, (double)(m_tracksHeight * m_document->tracksCount()));
4629     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
4630     for (int i = 0; i < collisions.count(); i++) {
4631         if (collisions.at(i)->type() == AVWIDGET) {
4632             return static_cast < ClipItem *>(collisions.at(i));
4633         }
4634     }
4635     return NULL;
4636 }
4637
4638 AbstractClipItem *CustomTrackView::getMainActiveClip() const
4639 {
4640     QList<QGraphicsItem *> clips = scene()->selectedItems();
4641     if (clips.isEmpty()) {
4642         return getClipUnderCursor();
4643     } else {
4644         AbstractClipItem *item = NULL;
4645         for (int i = 0; i < clips.count(); ++i) {
4646             if (clips.count() == 1 || clips.at(i)->type() == AVWIDGET) {
4647                 item = static_cast < AbstractClipItem *>(clips.at(i));
4648                 if (clips.count() > 1 && item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos) break;
4649             }
4650         }
4651         if (item) return item;
4652     }
4653     return NULL;
4654 }
4655
4656 ClipItem *CustomTrackView::getActiveClipUnderCursor(bool allowOutsideCursor) const
4657 {
4658     QList<QGraphicsItem *> clips = scene()->selectedItems();
4659     if (clips.isEmpty()) {
4660         return getClipUnderCursor();
4661     } else {
4662         ClipItem *item;
4663         // remove all items in the list that are not clips
4664         for (int i = 0; i < clips.count();) {
4665             if (clips.at(i)->type() != AVWIDGET) clips.removeAt(i);
4666             else i++;
4667         }
4668         if (clips.count() == 1 && allowOutsideCursor) return static_cast < ClipItem *>(clips.at(0));
4669         for (int i = 0; i < clips.count(); ++i) {
4670             if (clips.at(i)->type() == AVWIDGET) {
4671                 item = static_cast < ClipItem *>(clips.at(i));
4672                 if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos)
4673                     return item;
4674             }
4675         }
4676     }
4677     return NULL;
4678 }
4679
4680 void CustomTrackView::setInPoint()
4681 {
4682     AbstractClipItem *clip = getActiveClipUnderCursor(true);
4683     if (clip == NULL) {
4684         if (m_dragItem && m_dragItem->type() == TRANSITIONWIDGET) {
4685             clip = m_dragItem;
4686         } else {
4687             emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4688             return;
4689         }
4690     }
4691     ItemInfo startInfo = clip->info();
4692     ItemInfo endInfo = startInfo;
4693     endInfo.startPos = GenTime(m_cursorPos, m_document->fps());
4694     if (endInfo.startPos >= startInfo.endPos || endInfo.startPos < startInfo.startPos - startInfo.cropStart) {
4695         // Check for invalid resize
4696         emit displayMessage(i18n("Invalid action"), ErrorMessage);
4697         return;
4698     } else if (endInfo.startPos < startInfo.startPos) {
4699         int length = m_document->renderer()->mltGetSpaceLength(endInfo.startPos, m_document->tracksCount() - startInfo.track, false);
4700         if ((clip->type() == TRANSITIONWIDGET && itemCollision(clip, endInfo) == true) || (
4701                     (clip->type() == AVWIDGET) && length < (startInfo.startPos - endInfo.startPos).frames(m_document->fps()))) {
4702             emit displayMessage(i18n("Invalid action"), ErrorMessage);
4703             return;
4704         }
4705     }
4706     if (clip->type() == TRANSITIONWIDGET) {
4707         m_commandStack->push(new MoveTransitionCommand(this, startInfo, endInfo, true));
4708     } else m_commandStack->push(new ResizeClipCommand(this, startInfo, endInfo, true, false));
4709 }
4710
4711 void CustomTrackView::setOutPoint()
4712 {
4713     AbstractClipItem *clip = getActiveClipUnderCursor(true);
4714     if (clip == NULL) {
4715         if (m_dragItem && m_dragItem->type() == TRANSITIONWIDGET) {
4716             clip = m_dragItem;
4717         } else {
4718             emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4719             return;
4720         }
4721     }
4722     ItemInfo startInfo = clip->info();
4723     ItemInfo endInfo = clip->info();
4724     endInfo.endPos = GenTime(m_cursorPos, m_document->fps());
4725     CLIPTYPE type = (CLIPTYPE) static_cast <ClipItem *>(clip)->clipType();
4726     if (endInfo.endPos <= startInfo.startPos || (type != IMAGE && type != COLOR && type != TEXT && endInfo.endPos > startInfo.startPos + clip->maxDuration() - startInfo.cropStart)) {
4727         // Check for invalid resize
4728         emit displayMessage(i18n("Invalid action"), ErrorMessage);
4729         return;
4730     } else if (endInfo.endPos > startInfo.endPos) {
4731         int length = m_document->renderer()->mltGetSpaceLength(startInfo.endPos, m_document->tracksCount() - startInfo.track, false);
4732         if ((clip->type() == TRANSITIONWIDGET && itemCollision(clip, endInfo) == true) || (clip->type() == AVWIDGET && length != -1 && length < (endInfo.endPos - startInfo.endPos).frames(m_document->fps()))) {
4733             kDebug() << " RESIZE ERROR, BLNK: " << length << ", RESIZE: " << (endInfo.endPos - startInfo.endPos).frames(m_document->fps());
4734             emit displayMessage(i18n("Invalid action"), ErrorMessage);
4735             return;
4736         }
4737     }
4738
4739
4740     if (clip->type() == TRANSITIONWIDGET) {
4741         m_commandStack->push(new MoveTransitionCommand(this, startInfo, endInfo, true));
4742     } else m_commandStack->push(new ResizeClipCommand(this, startInfo, endInfo, true, false));
4743 }
4744
4745 void CustomTrackView::slotUpdateAllThumbs()
4746 {
4747     QList<QGraphicsItem *> itemList = items();
4748     //if (itemList.isEmpty()) return;
4749     ClipItem *item;
4750     const QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
4751     for (int i = 0; i < itemList.count(); i++) {
4752         if (itemList.at(i)->type() == AVWIDGET) {
4753             item = static_cast <ClipItem *>(itemList.at(i));
4754             if (item->clipType() != COLOR && item->clipType() != AUDIO) {
4755                 // Check if we have a cached thumbnail
4756                 if (item->clipType() == IMAGE || item->clipType() == TEXT) {
4757                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
4758                     if (QFile::exists(thumb)) {
4759                         QPixmap pix(thumb);
4760                         item->slotSetStartThumb(pix);
4761                     }
4762                 } else {
4763                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
4764                     QString endThumb = startThumb;
4765                     startThumb.append(QString::number(item->speedIndependantCropStart().frames(m_document->fps())) + ".png");
4766                     endThumb.append(QString::number((item->speedIndependantCropStart() + item->speedIndependantCropDuration()).frames(m_document->fps()) - 1) + ".png");
4767                     if (QFile::exists(startThumb)) {
4768                         QPixmap pix(startThumb);
4769                         item->slotSetStartThumb(pix);
4770                     }
4771                     if (QFile::exists(endThumb)) {
4772                         QPixmap pix(endThumb);
4773                         item->slotSetEndThumb(pix);
4774                     }
4775                 }
4776             }
4777             item->refreshClip(false);
4778             qApp->processEvents();
4779         }
4780     }
4781     viewport()->update();
4782 }
4783
4784 void CustomTrackView::saveThumbnails()
4785 {
4786     QList<QGraphicsItem *> itemList = items();
4787     ClipItem *item;
4788     QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
4789     for (int i = 0; i < itemList.count(); i++) {
4790         if (itemList.at(i)->type() == AVWIDGET) {
4791             item = static_cast <ClipItem *>(itemList.at(i));
4792             if (item->clipType() != COLOR) {
4793                 // Check if we have a cached thumbnail
4794                 if (item->clipType() == IMAGE || item->clipType() == TEXT || item->clipType() == AUDIO) {
4795                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
4796                     if (!QFile::exists(thumb)) {
4797                         QPixmap pix(item->startThumb());
4798                         pix.save(thumb);
4799                     }
4800                 } else {
4801                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
4802                     QString endThumb = startThumb;
4803                     startThumb.append(QString::number(item->speedIndependantCropStart().frames(m_document->fps())) + ".png");
4804                     endThumb.append(QString::number((item->speedIndependantCropStart() + item->speedIndependantCropDuration()).frames(m_document->fps()) - 1) + ".png");
4805                     if (!QFile::exists(startThumb)) {
4806                         QPixmap pix(item->startThumb());
4807                         pix.save(startThumb);
4808                     }
4809                     if (!QFile::exists(endThumb)) {
4810                         QPixmap pix(item->endThumb());
4811                         pix.save(endThumb);
4812                     }
4813                 }
4814             }
4815         }
4816     }
4817 }
4818
4819
4820 void CustomTrackView::slotInsertTrack(int ix)
4821 {
4822     TrackDialog d(m_document, parentWidget());
4823     d.label->setText(i18n("Insert track"));
4824     d.track_nb->setMaximum(m_document->tracksCount() - 1);
4825     d.track_nb->setValue(ix);
4826     d.setWindowTitle(i18n("Insert New Track"));
4827     d.slotUpdateName(ix);
4828
4829     if (d.exec() == QDialog::Accepted) {
4830         ix = d.track_nb->value();
4831         if (d.before_select->currentIndex() == 1) {
4832             ix++;
4833         }
4834         TrackInfo info;
4835         if (d.video_track->isChecked()) {
4836             info.type = VIDEOTRACK;
4837             info.isMute = false;
4838             info.isBlind = false;
4839             info.isLocked = false;
4840         } else {
4841             info.type = AUDIOTRACK;
4842             info.isMute = false;
4843             info.isBlind = true;
4844             info.isLocked = false;
4845         }
4846         AddTrackCommand *addTrack = new AddTrackCommand(this, ix, info, true);
4847         m_commandStack->push(addTrack);
4848         setDocumentModified();
4849     }
4850 }
4851
4852 void CustomTrackView::slotDeleteTrack(int ix)
4853 {
4854     TrackDialog d(m_document, parentWidget());
4855     d.label->setText(i18n("Delete track"));
4856     d.before_select->setHidden(true);
4857     d.track_nb->setMaximum(m_document->tracksCount() - 1);
4858     d.track_nb->setValue(ix);
4859     d.slotUpdateName(ix);
4860     d.setWindowTitle(i18n("Delete Track"));
4861     d.video_track->setHidden(true);
4862     d.audio_track->setHidden(true);
4863     if (d.exec() == QDialog::Accepted) {
4864         ix = d.track_nb->value();
4865         TrackInfo info = m_document->trackInfoAt(m_document->tracksCount() - ix - 1);
4866         deleteTimelineTrack(ix, info);
4867         setDocumentModified();
4868         /*AddTrackCommand* command = new AddTrackCommand(this, ix, info, false);
4869         m_commandStack->push(command);*/
4870     }
4871 }
4872
4873 void CustomTrackView::slotChangeTrack(int ix)
4874 {
4875     TrackDialog d(m_document, parentWidget());
4876     d.label->setText(i18n("Change track"));
4877     d.before_select->setHidden(true);
4878     d.track_nb->setMaximum(m_document->tracksCount() - 1);
4879     d.track_nb->setValue(ix);
4880     d.slotUpdateName(ix);
4881     d.setWindowTitle(i18n("Change Track Type"));
4882
4883     if (m_document->trackInfoAt(m_document->tracksCount() - ix - 1).type == VIDEOTRACK)
4884         d.video_track->setChecked(true);
4885     else
4886         d.audio_track->setChecked(true);
4887
4888     if (d.exec() == QDialog::Accepted) {
4889         TrackInfo info;
4890         info.isLocked = false;
4891         info.isMute = false;
4892         ix = d.track_nb->value();
4893
4894         if (d.video_track->isChecked()) {
4895             info.type = VIDEOTRACK;
4896             info.isBlind = false;
4897         } else {
4898             info.type = AUDIOTRACK;
4899             info.isBlind = true;
4900         }
4901         changeTimelineTrack(ix, info);
4902         setDocumentModified();
4903     }
4904 }
4905
4906
4907 void CustomTrackView::deleteTimelineTrack(int ix, TrackInfo trackinfo)
4908 {
4909     double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
4910     QRectF r(0, startY, sceneRect().width(), m_tracksHeight / 2 - 1);
4911     QList<QGraphicsItem *> selection = m_scene->items(r);
4912     QUndoCommand *deleteTrack = new QUndoCommand();
4913     deleteTrack->setText("Delete track");
4914
4915     // Delete all clips in selected track
4916     for (int i = 0; i < selection.count(); i++) {
4917         if (selection.at(i)->type() == AVWIDGET) {
4918             ClipItem *item =  static_cast <ClipItem *>(selection.at(i));
4919             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, true, deleteTrack);
4920             m_scene->removeItem(item);
4921             delete item;
4922             item = NULL;
4923         } else if (selection.at(i)->type() == TRANSITIONWIDGET) {
4924             Transition *item =  static_cast <Transition *>(selection.at(i));
4925             new AddTransitionCommand(this, item->info(), item->transitionEndTrack(), item->toXML(), true, false, deleteTrack);
4926             m_scene->removeItem(item);
4927             delete item;
4928             item = NULL;
4929         }
4930     }
4931
4932     new AddTrackCommand(this, ix, trackinfo, false, deleteTrack);
4933     m_commandStack->push(deleteTrack);
4934 }
4935
4936 void CustomTrackView::changeTimelineTrack(int ix, TrackInfo trackinfo)
4937 {
4938     TrackInfo oldinfo = m_document->trackInfoAt(m_document->tracksCount() - ix - 1);
4939     ChangeTrackCommand *changeTrack = new ChangeTrackCommand(this, ix, oldinfo, trackinfo);
4940     m_commandStack->push(changeTrack);
4941 }
4942
4943 void CustomTrackView::autoTransition()
4944 {
4945     QList<QGraphicsItem *> itemList = scene()->selectedItems();
4946     if (itemList.count() != 1 || itemList.at(0)->type() != TRANSITIONWIDGET) {
4947         emit displayMessage(i18n("You must select one transition for this action"), ErrorMessage);
4948         return;
4949     }
4950     Transition *tr = static_cast <Transition*>(itemList.at(0));
4951     tr->setAutomatic(!tr->isAutomatic());
4952     QDomElement transition = tr->toXML();
4953     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);
4954     setDocumentModified();
4955 }
4956
4957
4958 QStringList CustomTrackView::getLadspaParams(QDomElement effect) const
4959 {
4960     QStringList result;
4961     QDomNodeList params = effect.elementsByTagName("parameter");
4962     for (int i = 0; i < params.count(); i++) {
4963         QDomElement e = params.item(i).toElement();
4964         if (!e.isNull() && e.attribute("type") == "constant") {
4965             if (e.hasAttribute("factor")) {
4966                 double factor = e.attribute("factor").toDouble();
4967                 double value = e.attribute("value").toDouble();
4968                 value = value / factor;
4969                 result.append(QString::number(value));
4970             } else result.append(e.attribute("value"));
4971         }
4972     }
4973     return result;
4974 }
4975
4976 void CustomTrackView::clipNameChanged(const QString id, const QString name)
4977 {
4978     QList<QGraphicsItem *> list = scene()->items();
4979     ClipItem *clip = NULL;
4980     for (int i = 0; i < list.size(); ++i) {
4981         if (list.at(i)->type() == AVWIDGET) {
4982             clip = static_cast <ClipItem *>(list.at(i));
4983             if (clip->clipProducer() == id) {
4984                 clip->setClipName(name);
4985             }
4986         }
4987     }
4988     viewport()->update();
4989 }
4990
4991 void CustomTrackView::getClipAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum)
4992 {
4993     minimum = GenTime();
4994     maximum = GenTime();
4995     QList<QGraphicsItem *> selection;
4996     selection = m_scene->items(0, item->track() * m_tracksHeight + m_tracksHeight / 2, sceneRect().width(), 2);
4997     selection.removeAll(item);
4998     for (int i = 0; i < selection.count(); i++) {
4999         AbstractClipItem *clip = static_cast <AbstractClipItem *>(selection.at(i));
5000         if (clip && clip->type() == AVWIDGET) {
5001             if (clip->endPos() <= item->startPos() && clip->endPos() > minimum) minimum = clip->endPos();
5002             if (clip->startPos() > item->startPos() && (clip->startPos() < maximum || maximum == GenTime())) maximum = clip->startPos();
5003         }
5004     }
5005 }
5006
5007 void CustomTrackView::getTransitionAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum)
5008 {
5009     minimum = GenTime();
5010     maximum = GenTime();
5011     QList<QGraphicsItem *> selection;
5012     selection = m_scene->items(0, (item->track() + 1) * m_tracksHeight, sceneRect().width(), 2);
5013     selection.removeAll(item);
5014     for (int i = 0; i < selection.count(); i++) {
5015         AbstractClipItem *clip = static_cast <AbstractClipItem *>(selection.at(i));
5016         if (clip && clip->type() == TRANSITIONWIDGET) {
5017             if (clip->endPos() <= item->startPos() && clip->endPos() > minimum) minimum = clip->endPos();
5018             if (clip->startPos() > item->startPos() && (clip->startPos() < maximum || maximum == GenTime())) maximum = clip->startPos();
5019         }
5020     }
5021 }
5022
5023
5024 void CustomTrackView::loadGroups(const QDomNodeList groups)
5025 {
5026     for (int i = 0; i < groups.count(); i++) {
5027         QDomNodeList children = groups.at(i).childNodes();
5028         scene()->clearSelection();
5029         for (int nodeindex = 0; nodeindex < children.count(); nodeindex++) {
5030             QDomNode n = children.item(nodeindex);
5031             QDomElement elem = n.toElement();
5032             int pos = elem.attribute("position").toInt();
5033             int track = elem.attribute("track").toInt();
5034             if (elem.tagName() == "clipitem") {
5035                 ClipItem *clip = getClipItemAt(pos, track); //m_document->tracksCount() - transitiontrack);
5036                 if (clip) clip->setSelected(true);
5037             } else {
5038                 Transition *clip = getTransitionItemAt(pos, track); //m_document->tracksCount() - transitiontrack);
5039                 if (clip) clip->setSelected(true);
5040             }
5041         }
5042         groupSelectedItems(false, true);
5043     }
5044 }
5045
5046 void CustomTrackView::splitAudio()
5047 {
5048     resetSelectionGroup();
5049     QList<QGraphicsItem *> selection = scene()->selectedItems();
5050     if (selection.isEmpty()) {
5051         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
5052         return;
5053     }
5054     QUndoCommand *splitCommand = new QUndoCommand();
5055     splitCommand->setText(i18n("Split audio"));
5056     for (int i = 0; i < selection.count(); i++) {
5057         if (selection.at(i)->type() == AVWIDGET) {
5058             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
5059             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
5060                 if (clip->parentItem()) {
5061                     emit displayMessage(i18n("Cannot split audio of grouped clips"), ErrorMessage);
5062                 } else {
5063                     new SplitAudioCommand(this, clip->track(), clip->startPos(), splitCommand);
5064                 }
5065             }
5066         }
5067     }
5068     m_commandStack->push(splitCommand);
5069 }
5070
5071 void CustomTrackView::doSplitAudio(const GenTime &pos, int track, bool split)
5072 {
5073     ClipItem *clip = getClipItemAt(pos, track);
5074     if (clip == NULL) {
5075         kDebug() << "// Cannot find clip to split!!!";
5076         return;
5077     }
5078     if (split) {
5079         int start = pos.frames(m_document->fps());
5080         int freetrack = m_document->tracksCount() - track - 1;
5081         for (; freetrack > 0; freetrack--) {
5082             kDebug() << "// CHK DOC TRK:" << freetrack << ", DUR:" << m_document->renderer()->mltTrackDuration(freetrack);
5083             if (m_document->trackInfoAt(freetrack - 1).type == AUDIOTRACK) {
5084                 kDebug() << "// CHK DOC TRK:" << freetrack << ", DUR:" << m_document->renderer()->mltTrackDuration(freetrack);
5085                 if (m_document->renderer()->mltTrackDuration(freetrack) < start || m_document->renderer()->mltGetSpaceLength(pos, freetrack, false) >= clip->cropDuration().frames(m_document->fps())) {
5086                     kDebug() << "FOUND SPACE ON TRK: " << freetrack;
5087                     break;
5088                 }
5089             }
5090         }
5091         kDebug() << "GOT TRK: " << track;
5092         if (freetrack == 0) {
5093             emit displayMessage(i18n("No empty space to put clip audio"), ErrorMessage);
5094         } else {
5095             ItemInfo info = clip->info();
5096             info.track = m_document->tracksCount() - freetrack;
5097             addClip(clip->xml(), clip->clipProducer(), info, clip->effectList());
5098             scene()->clearSelection();
5099             clip->setSelected(true);
5100             ClipItem *audioClip = getClipItemAt(start, info.track);
5101             if (audioClip) {
5102                 clip->setVideoOnly(true);
5103                 if (m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - track, start, clip->baseClip()->videoProducer()) == false) {
5104                     emit displayMessage(i18n("Cannot update clip (time: %1, track: %2)", start, track), ErrorMessage);
5105                 }
5106                 if (m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - info.track, start, clip->baseClip()->audioProducer(info.track)) == false) {
5107                     emit displayMessage(i18n("Cannot update clip (time: %1, track: %2)", start, info.track), ErrorMessage);
5108                 }
5109                 audioClip->setSelected(true);
5110                 audioClip->setAudioOnly(true);
5111                 groupSelectedItems(false, true);
5112             }
5113         }
5114     } else {
5115         // unsplit clip: remove audio part and change video part to normal clip
5116         if (clip->parentItem() == NULL || clip->parentItem()->type() != GROUPWIDGET) {
5117             kDebug() << "//CANNOT FIND CLP GRP";
5118             return;
5119         }
5120         AbstractGroupItem *grp = static_cast <AbstractGroupItem *>(clip->parentItem());
5121         QList<QGraphicsItem *> children = grp->childItems();
5122         if (children.count() != 2) {
5123             kDebug() << "//SOMETHING IS WRONG WITH CLP GRP";
5124             return;
5125         }
5126         for (int i = 0; i < children.count(); i++) {
5127             if (children.at(i) != clip) {
5128                 ClipItem *clp = static_cast <ClipItem *>(children.at(i));
5129                 ItemInfo info = clip->info();
5130                 deleteClip(clp->info());
5131                 clip->setVideoOnly(false);
5132                 if (!m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - info.track, info.startPos.frames(m_document->fps()), clip->baseClip()->producer(info.track))) {
5133                     emit displayMessage(i18n("Cannot update clip (time: %1, track: %2)", info.startPos.frames(m_document->fps()), info.track), ErrorMessage);
5134                 }
5135                 break;
5136             }
5137         }
5138         clip->setFlag(QGraphicsItem::ItemIsMovable, true);
5139         m_document->clipManager()->removeGroup(grp);
5140         scene()->destroyItemGroup(grp);
5141     }
5142 }
5143
5144 void CustomTrackView::setVideoOnly()
5145 {
5146     resetSelectionGroup();
5147     QList<QGraphicsItem *> selection = scene()->selectedItems();
5148     if (selection.isEmpty()) {
5149         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
5150         return;
5151     }
5152     QUndoCommand *videoCommand = new QUndoCommand();
5153     videoCommand->setText(i18n("Video only"));
5154     for (int i = 0; i < selection.count(); i++) {
5155         if (selection.at(i)->type() == AVWIDGET) {
5156             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
5157             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
5158                 if (clip->parentItem()) {
5159                     emit displayMessage(i18n("Cannot change grouped clips"), ErrorMessage);
5160                 } else {
5161                     new ChangeClipTypeCommand(this, clip->track(), clip->startPos(), true, false, clip->isVideoOnly(), clip->isAudioOnly(), videoCommand);
5162                 }
5163             }
5164         }
5165     }
5166     m_commandStack->push(videoCommand);
5167 }
5168
5169 void CustomTrackView::setAudioOnly()
5170 {
5171     resetSelectionGroup();
5172     QList<QGraphicsItem *> selection = scene()->selectedItems();
5173     if (selection.isEmpty()) {
5174         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
5175         return;
5176     }
5177     QUndoCommand *videoCommand = new QUndoCommand();
5178     videoCommand->setText(i18n("Audio only"));
5179     for (int i = 0; i < selection.count(); i++) {
5180         if (selection.at(i)->type() == AVWIDGET) {
5181             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
5182             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
5183                 if (clip->parentItem()) {
5184                     emit displayMessage(i18n("Cannot change grouped clips"), ErrorMessage);
5185                 } else {
5186                     new ChangeClipTypeCommand(this, clip->track(), clip->startPos(), false, true, clip->isVideoOnly(), clip->isAudioOnly(), videoCommand);
5187                 }
5188             }
5189         }
5190     }
5191     m_commandStack->push(videoCommand);
5192 }
5193
5194 void CustomTrackView::setAudioAndVideo()
5195 {
5196     resetSelectionGroup();
5197     QList<QGraphicsItem *> selection = scene()->selectedItems();
5198     if (selection.isEmpty()) {
5199         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
5200         return;
5201     }
5202     QUndoCommand *videoCommand = new QUndoCommand();
5203     videoCommand->setText(i18n("Audio and Video"));
5204     for (int i = 0; i < selection.count(); i++) {
5205         if (selection.at(i)->type() == AVWIDGET) {
5206             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
5207             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
5208                 if (clip->parentItem()) {
5209                     emit displayMessage(i18n("Cannot change grouped clips"), ErrorMessage);
5210                 } else {
5211                     new ChangeClipTypeCommand(this, clip->track(), clip->startPos(), false, false, clip->isVideoOnly(), clip->isAudioOnly(), videoCommand);
5212                 }
5213             }
5214         }
5215     }
5216     m_commandStack->push(videoCommand);
5217 }
5218
5219 void CustomTrackView::doChangeClipType(const GenTime &pos, int track, bool videoOnly, bool audioOnly)
5220 {
5221     ClipItem *clip = getClipItemAt(pos, track);
5222     if (clip == NULL) {
5223         kDebug() << "// Cannot find clip to split!!!";
5224         return;
5225     }
5226     if (videoOnly) {
5227         int start = pos.frames(m_document->fps());
5228         clip->setVideoOnly(true);
5229         clip->setAudioOnly(false);
5230         if (m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - track, start, clip->baseClip()->videoProducer()) == false) {
5231             emit displayMessage(i18n("Cannot update clip (time: %1, track: %2)", start, track), ErrorMessage);
5232         }
5233     } else if (audioOnly) {
5234         int start = pos.frames(m_document->fps());
5235         clip->setAudioOnly(true);
5236         clip->setVideoOnly(false);
5237         if (m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - track, start, clip->baseClip()->audioProducer(track)) == false) {
5238             emit displayMessage(i18n("Cannot update clip (time: %1, track: %2)", start, track), ErrorMessage);
5239         }
5240     } else {
5241         int start = pos.frames(m_document->fps());
5242         clip->setAudioOnly(false);
5243         clip->setVideoOnly(false);
5244         if (m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - track, start, clip->baseClip()->producer(track)) == false) {
5245             emit displayMessage(i18n("Cannot update clip (time: %1, track: %2)", start, track), ErrorMessage);
5246         }
5247     }
5248     clip->update();
5249     setDocumentModified();
5250 }
5251
5252 void CustomTrackView::updateClipTypeActions(ClipItem *clip)
5253 {
5254     if (clip == NULL || (clip->clipType() != AV && clip->clipType() != PLAYLIST)) {
5255         m_clipTypeGroup->setEnabled(false);
5256     } else {
5257         m_clipTypeGroup->setEnabled(true);
5258         QList <QAction *> actions = m_clipTypeGroup->actions();
5259         QString lookup;
5260         if (clip->isAudioOnly()) lookup = "clip_audio_only";
5261         else if (clip->isVideoOnly()) lookup = "clip_video_only";
5262         else  lookup = "clip_audio_and_video";
5263         for (int i = 0; i < actions.count(); i++) {
5264             if (actions.at(i)->data().toString() == lookup) {
5265                 actions.at(i)->setChecked(true);
5266                 break;
5267             }
5268         }
5269     }
5270 }
5271
5272 void CustomTrackView::reloadTransitionLumas()
5273 {
5274     QString lumaNames;
5275     QString lumaFiles;
5276     QDomElement lumaTransition = MainWindow::transitions.getEffectByTag("luma", "luma");
5277     QDomNodeList params = lumaTransition.elementsByTagName("parameter");
5278     for (int i = 0; i < params.count(); i++) {
5279         QDomElement e = params.item(i).toElement();
5280         if (e.attribute("tag") == "resource") {
5281             lumaNames = e.attribute("paramlistdisplay");
5282             lumaFiles = e.attribute("paramlist");
5283             break;
5284         }
5285     }
5286
5287     QList<QGraphicsItem *> itemList = items();
5288     Transition *transitionitem;
5289     QDomElement transitionXml;
5290     for (int i = 0; i < itemList.count(); i++) {
5291         if (itemList.at(i)->type() == TRANSITIONWIDGET) {
5292             transitionitem = static_cast <Transition*>(itemList.at(i));
5293             transitionXml = transitionitem->toXML();
5294             if (transitionXml.attribute("id") == "luma" && transitionXml.attribute("tag") == "luma") {
5295                 QDomNodeList params = transitionXml.elementsByTagName("parameter");
5296                 for (int i = 0; i < params.count(); i++) {
5297                     QDomElement e = params.item(i).toElement();
5298                     if (e.attribute("tag") == "resource") {
5299                         e.setAttribute("paramlistdisplay", lumaNames);
5300                         e.setAttribute("paramlist", lumaFiles);
5301                         break;
5302                     }
5303                 }
5304             }
5305             if (transitionXml.attribute("id") == "composite" && transitionXml.attribute("tag") == "composite") {
5306                 QDomNodeList params = transitionXml.elementsByTagName("parameter");
5307                 for (int i = 0; i < params.count(); i++) {
5308                     QDomElement e = params.item(i).toElement();
5309                     if (e.attribute("tag") == "luma") {
5310                         e.setAttribute("paramlistdisplay", lumaNames);
5311                         e.setAttribute("paramlist", lumaFiles);
5312                         break;
5313                     }
5314                 }
5315             }
5316         }
5317     }
5318     emit transitionItemSelected(NULL);
5319 }
5320
5321 double CustomTrackView::fps() const
5322 {
5323     return m_document->fps();
5324 }
5325
5326 void CustomTrackView::updateProjectFps()
5327 {
5328     // update all clips to the new fps
5329     resetSelectionGroup();
5330     scene()->clearSelection();
5331     m_dragItem = NULL;
5332     QList<QGraphicsItem *> itemList = items();
5333     for (int i = 0; i < itemList.count(); i++) {
5334         // remove all items and re-add them one by one
5335         if (itemList.at(i) != m_cursorLine && itemList.at(i)->parentItem() == NULL) m_scene->removeItem(itemList.at(i));
5336     }
5337     for (int i = 0; i < itemList.count(); i++) {
5338         if (itemList.at(i)->parentItem() == 0 && (itemList.at(i)->type() == AVWIDGET || itemList.at(i)->type() == TRANSITIONWIDGET)) {
5339             AbstractClipItem *clip = static_cast <AbstractClipItem *>(itemList.at(i));
5340             clip->updateFps(m_document->fps());
5341             m_scene->addItem(clip);
5342         } else if (itemList.at(i)->type() == GROUPWIDGET) {
5343             AbstractGroupItem *grp = static_cast <AbstractGroupItem *>(itemList.at(i));
5344             QList<QGraphicsItem *> children = grp->childItems();
5345             for (int j = 0; j < children.count(); j++) {
5346                 if (children.at(j)->type() == AVWIDGET || children.at(j)->type() == TRANSITIONWIDGET) {
5347                     AbstractClipItem *clip = static_cast <AbstractClipItem *>(children.at(j));
5348                     clip->setFlag(QGraphicsItem::ItemIsMovable, true);
5349                     clip->updateFps(m_document->fps());
5350                 }
5351             }
5352             m_document->clipManager()->removeGroup(grp);
5353             m_scene->addItem(grp);
5354             scene()->destroyItemGroup(grp);
5355             for (int j = 0; j < children.count(); j++) {
5356                 if (children.at(j)->type() == AVWIDGET || children.at(j)->type() == TRANSITIONWIDGET) {
5357                     //children.at(j)->setParentItem(0);
5358                     children.at(j)->setSelected(true);
5359                 }
5360             }
5361             groupSelectedItems(true, true);
5362         } else if (itemList.at(i)->type() == GUIDEITEM) {
5363             Guide *g = static_cast<Guide *>(itemList.at(i));
5364             g->updatePos();
5365             m_scene->addItem(g);
5366         }
5367     }
5368     viewport()->update();
5369 }
5370
5371 void CustomTrackView::slotTrackDown()
5372 {
5373     if (m_selectedTrack > m_document->tracksCount() - 2) m_selectedTrack = 0;
5374     else m_selectedTrack++;
5375     emit updateTrackHeaders();
5376     QRectF rect(mapToScene(QPoint()).x(), m_selectedTrack * m_tracksHeight, 10, m_tracksHeight);
5377     ensureVisible(rect);
5378     viewport()->update();
5379 }
5380
5381 void CustomTrackView::slotTrackUp()
5382 {
5383     if (m_selectedTrack > 0) m_selectedTrack--;
5384     else m_selectedTrack = m_document->tracksCount() - 1;
5385     emit updateTrackHeaders();
5386     QRectF rect(mapToScene(QPoint()).x(), m_selectedTrack * m_tracksHeight, 10, m_tracksHeight);
5387     ensureVisible(rect);
5388     viewport()->update();
5389 }
5390
5391 int CustomTrackView::selectedTrack() const
5392 {
5393     return m_selectedTrack;
5394 }
5395
5396 void CustomTrackView::slotSelectTrack(int ix)
5397 {
5398     m_selectedTrack = qMax(0, ix);
5399     m_selectedTrack = qMin(ix, m_document->tracksCount() - 1);
5400     emit updateTrackHeaders();
5401     QRectF rect(mapToScene(QPoint()).x(), m_selectedTrack * m_tracksHeight, 10, m_tracksHeight);
5402     ensureVisible(rect);
5403     viewport()->update();
5404 }
5405
5406 void CustomTrackView::selectClip(bool add, bool group)
5407 {
5408     QRectF rect(m_cursorPos, m_selectedTrack * m_tracksHeight + m_tracksHeight / 2, 1, 1);
5409     QList<QGraphicsItem *> selection = m_scene->items(rect);
5410     resetSelectionGroup(group);
5411     if (!group) m_scene->clearSelection();
5412     for (int i = 0; i < selection.count(); i++) {
5413         if (selection.at(i)->type() == AVWIDGET) {
5414             selection.at(i)->setSelected(add);
5415             break;
5416         }
5417     }
5418     if (group) groupSelectedItems();
5419 }
5420
5421 void CustomTrackView::selectTransition(bool add, bool group)
5422 {
5423     QRectF rect(m_cursorPos, m_selectedTrack * m_tracksHeight + m_tracksHeight, 1, 1);
5424     QList<QGraphicsItem *> selection = m_scene->items(rect);
5425     resetSelectionGroup(group);
5426     if (!group) m_scene->clearSelection();
5427     for (int i = 0; i < selection.count(); i++) {
5428         if (selection.at(i)->type() == TRANSITIONWIDGET) {
5429             selection.at(i)->setSelected(add);
5430             break;
5431         }
5432     }
5433     if (group) groupSelectedItems();
5434 }
5435
5436 QStringList CustomTrackView::extractTransitionsLumas()
5437 {
5438     QStringList urls;
5439     QList<QGraphicsItem *> itemList = items();
5440     Transition *transitionitem;
5441     QDomElement transitionXml;
5442     for (int i = 0; i < itemList.count(); i++) {
5443         if (itemList.at(i)->type() == TRANSITIONWIDGET) {
5444             transitionitem = static_cast <Transition*>(itemList.at(i));
5445             transitionXml = transitionitem->toXML();
5446             QString luma = EffectsList::parameter(transitionXml, "luma");
5447             if (!luma.isEmpty()) urls << luma;
5448         }
5449     }
5450     return urls;
5451 }
5452
5453 void CustomTrackView::setEditMode(EDITMODE mode)
5454 {
5455     m_scene->setEditMode(mode);
5456 }
5457
5458 void CustomTrackView::checkTrackSequence(int track)
5459 {
5460     QList <int> times = m_document->renderer()->checkTrackSequence(m_document->tracksCount() - track);
5461     //track = m_document->tracksCount() -track;
5462     QRectF rect(0, track * m_tracksHeight + m_tracksHeight / 2, sceneRect().width(), 2);
5463     QList<QGraphicsItem *> selection = m_scene->items(rect);
5464     QList <int> timelineList;
5465     timelineList.append(0);
5466     for (int i = 0; i < selection.count(); i++) {
5467         if (selection.at(i)->type() == AVWIDGET) {
5468             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
5469             int start = clip->startPos().frames(m_document->fps());
5470             int end = clip->endPos().frames(m_document->fps());
5471             if (!timelineList.contains(start)) timelineList.append(start);
5472             if (!timelineList.contains(end)) timelineList.append(end);
5473         }
5474     }
5475     qSort(timelineList);
5476     kDebug() << "// COMPARE:\n" << times << "\n" << timelineList << "\n-------------------";
5477     if (times != timelineList) KMessageBox::sorry(this, i18n("error"), i18n("TRACTOR"));
5478 }
5479
5480