git.sesse.net Git - kdenlive/blob - src/customtrackview.cpp

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