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(int pos, int track) {
2770     QList<QGraphicsItem *> list = scene()->items(QPointF(pos, (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::getTransitionItemAt(GenTime pos, int track) {
2782     return getTransitionItemAt(pos.frames(m_document->fps()), track);
2783 }
2784
2785 Transition *CustomTrackView::getTransitionItemAtEnd(GenTime pos, int track) {
2786     int framepos = (int)(pos.frames(m_document->fps()));
2787     QList<QGraphicsItem *> list = scene()->items(QPointF(framepos - 1, (track + 1) * m_tracksHeight));
2788     Transition *clip = NULL;
2789     for (int i = 0; i < list.size(); i++) {
2790         if (list.at(i)->type() == TRANSITIONWIDGET) {
2791             Transition *test = static_cast <Transition *>(list.at(i));
2792             if (test->endPos() == pos) clip = test;
2793             break;
2794         }
2795     }
2796     return clip;
2797 }
2798
2799 Transition *CustomTrackView::getTransitionItemAtStart(GenTime pos, int track) {
2800     QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), (track + 1) * m_tracksHeight));
2801     Transition *clip = NULL;
2802     for (int i = 0; i < list.size(); ++i) {
2803         if (list.at(i)->type() == TRANSITIONWIDGET) {
2804             Transition *test = static_cast <Transition *>(list.at(i));
2805             if (test->startPos() == pos) clip = test;
2806             break;
2807         }
2808     }
2809     return clip;
2810 }
2811
2812 void CustomTrackView::moveClip(const ItemInfo start, const ItemInfo end) {
2813     if (m_selectionGroup) resetSelectionGroup(false);
2814     ClipItem *item = getClipItemAt((int) start.startPos.frames(m_document->fps()) + 1, start.track);
2815     if (!item) {
2816         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);
2817         kDebug() << "----------------  ERROR, CANNOT find clip to move at.. ";
2818         return;
2819     }
2820     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));
2821     if (success) {
2822         bool snap = KdenliveSettings::snaptopoints();
2823         KdenliveSettings::setSnaptopoints(false);
2824         item->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
2825
2826         int tracknumber = m_document->tracksCount() - end.track - 1;
2827         bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2828         m_scene->clearSelection();
2829         if (isLocked) item->setItemLocked(true);
2830         else {
2831             if (item->isItemLocked()) item->setItemLocked(false);
2832             item->setSelected(true);
2833         }
2834         if (item->baseClip()->isTransparent()) {
2835             // Also move automatic transition
2836             Transition *tr = getTransitionItemAt(start.startPos, start.track);
2837             if (tr && tr->isAutomatic()) {
2838                 tr->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
2839                 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);
2840                 tr->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
2841             }
2842         }
2843         KdenliveSettings::setSnaptopoints(snap);
2844         m_document->setModified(true);
2845     } else {
2846         // undo last move and emit error message
2847         emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(end.startPos.frames(m_document->fps()))), ErrorMessage);
2848     }
2849     kDebug() << " // MOVED CLIP TO: " << end.startPos.frames(25) << ", ITEM START: " << item->startPos().frames(25);
2850 }
2851
2852 void CustomTrackView::moveGroup(QList <ItemInfo> startClip, QList <ItemInfo> startTransition, const GenTime offset, const int trackOffset, bool reverseMove) {
2853     // Group Items
2854     kDebug() << "// GROUP MOVE; OFFSET: " << offset.frames(25) << ", TK OFF: " << trackOffset;
2855     resetSelectionGroup();
2856     m_scene->clearSelection();
2857     QList <QGraphicsItemGroup *> groups;
2858     for (int i = 0; i < startClip.count(); i++) {
2859         if (reverseMove) {
2860             startClip[i].startPos = startClip.at(i).startPos - offset;
2861             startClip[i].track = startClip.at(i).track - trackOffset;
2862         }
2863         ClipItem *clip = getClipItemAt(startClip.at(i).startPos, startClip.at(i).track);
2864         if (clip) {
2865             clip->setItemLocked(false);
2866             if (clip->parentItem()) clip->parentItem()->setSelected(true);
2867             else clip->setSelected(true);
2868             m_document->renderer()->mltRemoveClip(m_document->tracksCount() - startClip.at(i).track, startClip.at(i).startPos);
2869         }
2870     }
2871     for (int i = 0; i < startTransition.count(); i++) {
2872         if (reverseMove) {
2873             startTransition[i].startPos = startTransition.at(i).startPos - offset;
2874             startTransition[i].track = startTransition.at(i).track - trackOffset;
2875         }
2876         Transition *tr = getTransitionItemAt(startTransition.at(i).startPos, startTransition.at(i).track);
2877         if (tr) {
2878             tr->setItemLocked(false);
2879             if (tr->parentItem()) tr->parentItem()->setSelected(true);
2880             else tr->setSelected(true);
2881             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());
2882         }
2883     }
2884     groupSelectedItems(true);
2885     if (m_selectionGroup) {
2886         QPointF pos = m_selectionGroup->pos();
2887         qreal posx = pos.x() + offset.frames(m_document->fps());
2888         qreal posy = pos.y() + trackOffset * (qreal) m_tracksHeight;
2889         bool snap = KdenliveSettings::snaptopoints();
2890         KdenliveSettings::setSnaptopoints(false);
2891
2892         m_selectionGroup->setPos(posx, posy);
2893
2894         QPointF top = m_selectionGroup->sceneBoundingRect().topLeft();
2895         m_selectionGroup->setPos(top);
2896         m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
2897         m_selectionGroupInfo.track = m_selectionGroup->track();
2898
2899         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
2900         kDebug() << "// GRP MOVE; FOUND CHILDREN:" << children.count();
2901
2902         // Expand groups
2903         int max = children.count();
2904         for (int i = 0; i < max; i++) {
2905             if (children.at(i)->type() == GROUPWIDGET) {
2906                 children += children.at(i)->childItems();
2907             }
2908         }
2909         for (int i = 0; i < children.count(); i++) {
2910             // re-add items in correct place
2911             if (children.at(i)->type() != AVWIDGET && children.at(i)->type() != TRANSITIONWIDGET) continue;
2912             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
2913             item->updateItem();
2914             ItemInfo info = item->info();
2915             int tracknumber = m_document->tracksCount() - info.track - 1;
2916             bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2917             if (isLocked) item->setItemLocked(true);
2918             else if (item->isItemLocked()) item->setItemLocked(false);
2919
2920             if (item->type() == AVWIDGET) {
2921                 ClipItem *clip = static_cast <ClipItem*>(item);
2922                 info.track = m_document->tracksCount() - info.track;
2923                 m_document->renderer()->mltInsertClip(info, clip->xml(), clip->baseClip()->producer(info.track));
2924             } else {
2925                 Transition *tr = static_cast <Transition*>(item);
2926                 int newTrack = tr->transitionEndTrack();
2927                 kDebug() << "/// TRANSITION CURR TRK: " << newTrack;
2928                 if (!tr->forcedTrack()) {
2929                     newTrack += trackOffset;
2930                     if (newTrack < 0 || newTrack > m_document->tracksCount()) newTrack = getPreviousVideoTrack(info.track);
2931                 }
2932                 tr->updateTransitionEndTrack(newTrack);
2933                 kDebug() << "/// TRANSITION UPDATED TRK: " << newTrack;
2934                 m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2935             }
2936         }
2937         KdenliveSettings::setSnaptopoints(snap);
2938     }
2939
2940 }
2941
2942 void CustomTrackView::moveTransition(const ItemInfo start, const ItemInfo end) {
2943     Transition *item = getTransitionItemAt(start.startPos, start.track);
2944     if (!item) {
2945         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);
2946         kDebug() << "----------------  ERROR, CANNOT find transition to move... ";// << startPos.x() * m_scale * FRAME_SIZE + 1 << ", " << startPos.y() * m_tracksHeight + m_tracksHeight / 2;
2947         return;
2948     }
2949     //kDebug() << "----------------  Move TRANSITION FROM: " << startPos.x() << ", END:" << endPos.x() << ",TRACKS: " << oldtrack << " TO " << newtrack;
2950     bool snap = KdenliveSettings::snaptopoints();
2951     KdenliveSettings::setSnaptopoints(false);
2952     //kDebug()<<"///  RESIZE TRANS START: ("<< startPos.x()<<"x"<< startPos.y()<<") / ("<<endPos.x()<<"x"<< endPos.y()<<")";
2953     if (end.endPos - end.startPos == start.endPos - start.startPos) {
2954         // Transition was moved
2955         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
2956     } else if (end.endPos == start.endPos) {
2957         // Transition start resize
2958         item->resizeStart((int) end.startPos.frames(m_document->fps()));
2959     } else if (end.startPos == start.startPos) {
2960         // Transition end resize;
2961         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
2962     } else {
2963         // Move & resize
2964         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
2965         item->resizeStart((int) end.startPos.frames(m_document->fps()));
2966         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
2967     }
2968     //item->moveTransition(GenTime((int) (endPos.x() - startPos.x()), m_document->fps()));
2969     KdenliveSettings::setSnaptopoints(snap);
2970     item->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
2971     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);
2972 }
2973
2974 void CustomTrackView::resizeClip(const ItemInfo start, const ItemInfo end) {
2975     bool resizeClipStart = true;
2976     if (start.startPos == end.startPos) resizeClipStart = false;
2977     /*if (resizeClipStart) offset = 1;
2978     else offset = -1;*/
2979     ClipItem *item = getClipItemAt((int)(start.startPos.frames(m_document->fps())), start.track);
2980     if (!item) {
2981         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);
2982         kDebug() << "----------------  ERROR, CANNOT find clip to resize at... "; // << startPos;
2983         return;
2984     }
2985     if (item->parentItem()) {
2986         // Item is part of a group, reset group
2987         resetSelectionGroup();
2988     }
2989     bool snap = KdenliveSettings::snaptopoints();
2990     KdenliveSettings::setSnaptopoints(false);
2991     if (resizeClipStart && start.startPos != end.startPos) {
2992         ItemInfo clipinfo = item->info();
2993         clipinfo.track = m_document->tracksCount() - clipinfo.track;
2994         bool success = m_document->renderer()->mltResizeClipStart(clipinfo, end.startPos - item->startPos());
2995         if (success) {
2996             kDebug() << "RESIZE CLP STRAT TO:" << end.startPos.frames(m_document->fps()) << ", OLD ST: " << start.startPos.frames(25);
2997             item->resizeStart((int) end.startPos.frames(m_document->fps()));
2998             updateClipFade(item);
2999         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
3000     } else if (!resizeClipStart) {
3001         ItemInfo clipinfo = item->info();
3002         clipinfo.track = m_document->tracksCount() - clipinfo.track;
3003         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, end.endPos - clipinfo.startPos);
3004         if (success) {
3005             item->resizeEnd((int) end.endPos.frames(m_document->fps()));
3006             updateClipFade(item, true);
3007         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
3008     }
3009     if (end.cropStart != start.cropStart) {
3010         kDebug() << "// RESIZE CROP, DIFF: " << (end.cropStart - start.cropStart).frames(25);
3011         ItemInfo clipinfo = end;
3012         clipinfo.track = m_document->tracksCount() - end.track;
3013         bool success = m_document->renderer()->mltResizeClipCrop(clipinfo, end.cropStart - start.cropStart);
3014         if (success) {
3015             item->setCropStart(end.cropStart);
3016             item->resetThumbs();
3017         }
3018     }
3019     m_document->renderer()->doRefresh();
3020     KdenliveSettings::setSnaptopoints(snap);
3021 }
3022
3023 void CustomTrackView::updateClipFade(ClipItem * item, bool updateFadeOut) {
3024     if (!updateFadeOut) {
3025         int end = item->fadeIn();
3026         if (end != 0) {
3027             // there is a fade in effect
3028             int effectPos = item->hasEffect("volume", "fadein");
3029             if (effectPos != -1) {
3030                 QDomElement oldeffect = item->effectAt(effectPos);
3031                 int start = item->cropStart().frames(m_document->fps());
3032                 int max = item->cropDuration().frames(m_document->fps());
3033                 if (end > max) {
3034                     item->setFadeIn(max);
3035                     end = item->fadeIn();
3036                 }
3037                 end += start;
3038                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
3039                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
3040                 if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3041                     emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3042                 // if fade effect is displayed, update the effect edit widget with new clip duration
3043                 if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3044             }
3045             effectPos = item->hasEffect("brightness", "fade_from_black");
3046             if (effectPos != -1) {
3047                 QDomElement oldeffect = item->effectAt(effectPos);
3048                 int start = item->cropStart().frames(m_document->fps());
3049                 int max = item->cropDuration().frames(m_document->fps());
3050                 if (end > max) {
3051                     item->setFadeIn(max);
3052                     end = item->fadeIn();
3053                 }
3054                 end += start;
3055                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
3056                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
3057                 if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3058                     emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3059                 // if fade effect is displayed, update the effect edit widget with new clip duration
3060                 if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3061             }
3062         }
3063     } else {
3064         int start = item->fadeOut();
3065         if (start != 0) {
3066             // there is a fade in effect
3067             int effectPos = item->hasEffect("volume", "fadeout");
3068             if (effectPos != -1) {
3069                 QDomElement oldeffect = item->effectAt(effectPos);
3070                 int end = (item->duration() - item->cropStart()).frames(m_document->fps());
3071                 int max = item->cropDuration().frames(m_document->fps());
3072                 if (end > max) {
3073                     item->setFadeOut(max);
3074                     start = item->fadeOut();
3075                 }
3076                 start = end - start;
3077                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
3078                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
3079                 if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3080                     emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3081                 // if fade effect is displayed, update the effect edit widget with new clip duration
3082                 if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3083             }
3084             effectPos = item->hasEffect("brightness", "fade_to_black");
3085             if (effectPos != -1) {
3086                 QDomElement oldeffect = item->effectAt(effectPos);
3087                 int end = (item->duration() - item->cropStart()).frames(m_document->fps());
3088                 int max = item->cropDuration().frames(m_document->fps());
3089                 if (end > max) {
3090                     item->setFadeOut(max);
3091                     start = item->fadeOut();
3092                 }
3093                 start = end - start;
3094                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
3095                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
3096                 if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3097                     emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3098                 // if fade effect is displayed, update the effect edit widget with new clip duration
3099                 if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3100             }
3101         }
3102     }
3103 }
3104
3105 double CustomTrackView::getSnapPointForPos(double pos) {
3106     return m_scene->getSnapPointForPos(pos, KdenliveSettings::snaptopoints());
3107 }
3108
3109 void CustomTrackView::updateSnapPoints(AbstractClipItem *selected, QList <GenTime> offsetList, bool skipSelectedItems) {
3110     QList <GenTime> snaps;
3111     if (selected && offsetList.isEmpty()) offsetList.append(selected->duration());
3112     QList<QGraphicsItem *> itemList = items();
3113     for (int i = 0; i < itemList.count(); i++) {
3114         if (itemList.at(i) == selected) continue;
3115         if (skipSelectedItems && itemList.at(i)->isSelected()) continue;
3116         if (itemList.at(i)->type() == AVWIDGET) {
3117             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
3118             GenTime start = item->startPos();
3119             GenTime end = item->endPos();
3120             snaps.append(start);
3121             snaps.append(end);
3122             if (!offsetList.isEmpty()) {
3123                 for (int j = 0; j < offsetList.size(); j++) {
3124                     if (start > offsetList.at(j)) snaps.append(start - offsetList.at(j));
3125                     if (end > offsetList.at(j)) snaps.append(end - offsetList.at(j));
3126                 }
3127             }
3128             // Add clip markers
3129             QList < GenTime > markers = item->snapMarkers();
3130             for (int j = 0; j < markers.size(); ++j) {
3131                 GenTime t = markers.at(j);
3132                 snaps.append(t);
3133                 if (!offsetList.isEmpty()) {
3134                     for (int k = 0; k < offsetList.size(); k++) {
3135                         if (t > offsetList.at(k)) snaps.append(t - offsetList.at(k));
3136                     }
3137                 }
3138             }
3139         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
3140             Transition *transition = static_cast <Transition*>(itemList.at(i));
3141             GenTime start = transition->startPos();
3142             GenTime end = transition->endPos();
3143             snaps.append(start);
3144             snaps.append(end);
3145             if (!offsetList.isEmpty()) {
3146                 for (int j = 0; j < offsetList.size(); j++) {
3147                     if (start > offsetList.at(j)) snaps.append(start - offsetList.at(j));
3148                     if (end > offsetList.at(j)) snaps.append(end - offsetList.at(j));
3149                 }
3150             }
3151         }
3152     }
3153
3154     // add cursor position
3155     GenTime pos = GenTime(m_cursorPos, m_document->fps());
3156     snaps.append(pos);
3157     if (!offsetList.isEmpty()) {
3158         for (int j = 0; j < offsetList.size(); j++) {
3159             snaps.append(pos - offsetList.at(j));
3160         }
3161     }
3162
3163     // add guides
3164     for (int i = 0; i < m_guides.count(); i++) {
3165         snaps.append(m_guides.at(i)->position());
3166         if (!offsetList.isEmpty()) {
3167             for (int j = 0; j < offsetList.size(); j++) {
3168                 snaps.append(m_guides.at(i)->position() - offsetList.at(j));
3169             }
3170         }
3171     }
3172
3173     qSort(snaps);
3174     m_scene->setSnapList(snaps);
3175     //for (int i = 0; i < m_snapPoints.size(); ++i)
3176     //    kDebug() << "SNAP POINT: " << m_snapPoints.at(i).frames(25);
3177 }
3178
3179 void CustomTrackView::slotSeekToPreviousSnap() {
3180     updateSnapPoints(NULL);
3181     GenTime res = m_scene->previousSnapPoint(GenTime(m_cursorPos, m_document->fps()));
3182     setCursorPos((int) res.frames(m_document->fps()));
3183     checkScrolling();
3184 }
3185
3186 void CustomTrackView::slotSeekToNextSnap() {
3187     updateSnapPoints(NULL);
3188     GenTime res = m_scene->nextSnapPoint(GenTime(m_cursorPos, m_document->fps()));
3189     setCursorPos((int) res.frames(m_document->fps()));
3190     checkScrolling();
3191 }
3192
3193 void CustomTrackView::clipStart() {
3194     ClipItem *item = getMainActiveClip();
3195     if (item != NULL) {
3196         setCursorPos((int) item->startPos().frames(m_document->fps()));
3197         checkScrolling();
3198     }
3199 }
3200
3201 void CustomTrackView::clipEnd() {
3202     ClipItem *item = getMainActiveClip();
3203     if (item != NULL) {
3204         setCursorPos((int) item->endPos().frames(m_document->fps()) - 1);
3205         checkScrolling();
3206     }
3207 }
3208
3209 void CustomTrackView::slotAddClipMarker(const QString &id, GenTime t, QString c) {
3210     QString oldcomment = m_document->clipManager()->getClipById(id)->markerComment(t);
3211     AddMarkerCommand *command = new AddMarkerCommand(this, oldcomment, c, id, t, true);
3212     m_commandStack->push(command);
3213 }
3214
3215 void CustomTrackView::slotDeleteClipMarker(const QString &comment, const QString &id, const GenTime &position) {
3216     AddMarkerCommand *command = new AddMarkerCommand(this, comment, QString(), id, position, true);
3217     m_commandStack->push(command);
3218 }
3219
3220 void CustomTrackView::slotDeleteAllClipMarkers(const QString &id) {
3221     DocClipBase *base = m_document->clipManager()->getClipById(id);
3222     QList <CommentedTime> markers = base->commentedSnapMarkers();
3223
3224     if (markers.isEmpty()) {
3225         emit displayMessage(i18n("Clip has no markers"), ErrorMessage);
3226         return;
3227     }
3228     QUndoCommand *deleteMarkers = new QUndoCommand();
3229     deleteMarkers->setText("Delete clip markers");
3230
3231     for (int i = 0; i < markers.size(); i++) {
3232         new AddMarkerCommand(this, markers.at(i).comment(), QString(), id, markers.at(i).time(), true, deleteMarkers);
3233     }
3234     m_commandStack->push(deleteMarkers);
3235 }
3236
3237 void CustomTrackView::addMarker(const QString &id, const GenTime &pos, const QString comment) {
3238     DocClipBase *base = m_document->clipManager()->getClipById(id);
3239     if (!comment.isEmpty()) base->addSnapMarker(pos, comment);
3240     else base->deleteSnapMarker(pos);
3241     m_document->setModified(true);
3242     viewport()->update();
3243 }
3244
3245 bool sortGuidesList(const Guide *g1 , const Guide *g2) {
3246     return (*g1).position() < (*g2).position();
3247 }
3248
3249 void CustomTrackView::editGuide(const GenTime oldPos, const GenTime pos, const QString &comment) {
3250     if (oldPos > GenTime() && pos > GenTime()) {
3251         // move guide
3252         for (int i = 0; i < m_guides.count(); i++) {
3253             if (m_guides.at(i)->position() == oldPos) {
3254                 Guide *item = m_guides.at(i);
3255                 item->updateGuide(pos, comment);
3256                 break;
3257             }
3258         }
3259     } else if (pos > GenTime()) addGuide(pos, comment);
3260     else {
3261         // remove guide
3262         bool found = false;
3263         for (int i = 0; i < m_guides.count(); i++) {
3264             if (m_guides.at(i)->position() == oldPos) {
3265                 Guide *item = m_guides.takeAt(i);
3266                 delete item;
3267                 found = true;
3268                 break;
3269             }
3270         }
3271         if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
3272     }
3273     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
3274     m_document->syncGuides(m_guides);
3275 }
3276
3277 bool CustomTrackView::addGuide(const GenTime pos, const QString &comment) {
3278     for (int i = 0; i < m_guides.count(); i++) {
3279         if (m_guides.at(i)->position() == pos) {
3280             emit displayMessage(i18n("A guide already exists at position %1", m_document->timecode().getTimecodeFromFrames(pos.frames(m_document->fps()))), ErrorMessage);
3281             return false;
3282         }
3283     }
3284     Guide *g = new Guide(this, pos, comment, m_document->fps(), m_tracksHeight * m_document->tracksCount());
3285     scene()->addItem(g);
3286     m_guides.append(g);
3287     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
3288     m_document->syncGuides(m_guides);
3289     return true;
3290 }
3291
3292 void CustomTrackView::slotAddGuide() {
3293     CommentedTime marker(GenTime(m_cursorPos, m_document->fps()), i18n("Guide"));
3294     MarkerDialog d(NULL, marker, m_document->timecode(), i18n("Add Guide"), this);
3295     if (d.exec() != QDialog::Accepted) return;
3296     if (addGuide(d.newMarker().time(), d.newMarker().comment())) {
3297         EditGuideCommand *command = new EditGuideCommand(this, GenTime(), QString(), d.newMarker().time(), d.newMarker().comment(), false);
3298         m_commandStack->push(command);
3299     }
3300 }
3301
3302 void CustomTrackView::slotEditGuide() {
3303     GenTime pos = GenTime(m_cursorPos, m_document->fps());
3304     bool found = false;
3305     for (int i = 0; i < m_guides.count(); i++) {
3306         if (m_guides.at(i)->position() == pos) {
3307             slotEditGuide(m_guides.at(i)->info());
3308             found = true;
3309             break;
3310         }
3311     }
3312     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
3313 }
3314
3315 void CustomTrackView::slotEditGuide(CommentedTime guide) {
3316     MarkerDialog d(NULL, guide, m_document->timecode(), i18n("Edit Guide"), this);
3317     if (d.exec() == QDialog::Accepted) {
3318         EditGuideCommand *command = new EditGuideCommand(this, guide.time(), guide.comment(), d.newMarker().time(), d.newMarker().comment(), true);
3319         m_commandStack->push(command);
3320     }
3321 }
3322
3323
3324 void CustomTrackView::slotDeleteGuide() {
3325     GenTime pos = GenTime(m_cursorPos, m_document->fps());
3326     bool found = false;
3327     for (int i = 0; i < m_guides.count(); i++) {
3328         if (m_guides.at(i)->position() == pos) {
3329             EditGuideCommand *command = new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true);
3330             m_commandStack->push(command);
3331             found = true;
3332             break;
3333         }
3334     }
3335     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
3336 }
3337
3338 void CustomTrackView::slotDeleteAllGuides() {
3339     QUndoCommand *deleteAll = new QUndoCommand();
3340     deleteAll->setText("Delete all guides");
3341     for (int i = 0; i < m_guides.count(); i++) {
3342         new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true, deleteAll);
3343     }
3344     m_commandStack->push(deleteAll);
3345 }
3346
3347 void CustomTrackView::setTool(PROJECTTOOL tool) {
3348     m_tool = tool;
3349 }
3350
3351 void CustomTrackView::setScale(double scaleFactor) {
3352     QMatrix matrix;
3353     matrix = matrix.scale(scaleFactor, 1);
3354     m_scene->setScale(scaleFactor);
3355     //scale(scaleFactor, 1);
3356     m_animationTimer->stop();
3357     if (m_visualTip) {
3358         delete m_visualTip;
3359         m_visualTip = NULL;
3360     }
3361     if (m_animation) {
3362         delete m_animation;
3363         m_animation = NULL;
3364     }
3365
3366     //setSceneRect(0, 0, m_projectDuration + 100 * scaleFactor, sceneRect().height());
3367     setMatrix(matrix);
3368     int diff = sceneRect().width() - m_projectDuration;
3369     if (diff * matrix.m11() < 50) {
3370         if (matrix.m11() < 0.4) setSceneRect(0, 0, (m_projectDuration + 100 / matrix.m11()), sceneRect().height());
3371         else setSceneRect(0, 0, (m_projectDuration + 300), sceneRect().height());
3372     }
3373
3374     centerOn(QPointF(cursorPos(), m_tracksHeight));
3375     //verticalScrollBar()->setValue(vert);*/
3376 }
3377
3378 void CustomTrackView::slotRefreshGuides() {
3379     if (KdenliveSettings::showmarkers()) {
3380         kDebug() << "// refresh GUIDES";
3381         for (int i = 0; i < m_guides.count(); i++) {
3382             m_guides.at(i)->update();
3383         }
3384     }
3385 }
3386
3387 void CustomTrackView::drawBackground(QPainter * painter, const QRectF & rect) {
3388     QColor base = palette().button().color();
3389     QRectF r = rect;
3390     r.setWidth(r.width() + 1);
3391     painter->setClipRect(r);
3392     painter->drawLine(r.left(), 0, r.right(), 0);
3393     uint max = m_document->tracksCount();
3394     for (uint i = 0; i < max;i++) {
3395         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)));
3396         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)));
3397         painter->drawLine(r.left(), m_tracksHeight * (i + 1), r.right(), m_tracksHeight * (i + 1));
3398     }
3399     int lowerLimit = m_tracksHeight * m_document->tracksCount() + 1;
3400     if (height() > lowerLimit)
3401         painter->fillRect(QRectF(r.left(), lowerLimit, r.width(), height() - lowerLimit), QBrush(base));
3402 }
3403
3404 bool CustomTrackView::findString(const QString &text) {
3405     QString marker;
3406     for (int i = 0; i < m_searchPoints.size(); ++i) {
3407         marker = m_searchPoints.at(i).comment();
3408         if (marker.contains(text, Qt::CaseInsensitive)) {
3409             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
3410             int vert = verticalScrollBar()->value();
3411             int hor = cursorPos();
3412             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
3413             m_findIndex = i;
3414             return true;
3415         }
3416     }
3417     return false;
3418 }
3419
3420 bool CustomTrackView::findNextString(const QString &text) {
3421     QString marker;
3422     for (int i = m_findIndex + 1; i < m_searchPoints.size(); ++i) {
3423         marker = m_searchPoints.at(i).comment();
3424         if (marker.contains(text, Qt::CaseInsensitive)) {
3425             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
3426             int vert = verticalScrollBar()->value();
3427             int hor = cursorPos();
3428             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
3429             m_findIndex = i;
3430             return true;
3431         }
3432     }
3433     m_findIndex = -1;
3434     return false;
3435 }
3436
3437 void CustomTrackView::initSearchStrings() {
3438     m_searchPoints.clear();
3439     QList<QGraphicsItem *> itemList = items();
3440     for (int i = 0; i < itemList.count(); i++) {
3441         // parse all clip names
3442         if (itemList.at(i)->type() == AVWIDGET) {
3443             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
3444             GenTime start = item->startPos();
3445             CommentedTime t(start, item->clipName());
3446             m_searchPoints.append(t);
3447             // add all clip markers
3448             QList < CommentedTime > markers = item->commentedSnapMarkers();
3449             m_searchPoints += markers;
3450         }
3451     }
3452
3453     // add guides
3454     for (int i = 0; i < m_guides.count(); i++) {
3455         m_searchPoints.append(m_guides.at(i)->info());
3456     }
3457
3458     qSort(m_searchPoints);
3459 }
3460
3461 void CustomTrackView::clearSearchStrings() {
3462     m_searchPoints.clear();
3463     m_findIndex = 0;
3464 }
3465
3466 void CustomTrackView::copyClip() {
3467     while (m_copiedItems.count() > 0) {
3468         delete m_copiedItems.takeFirst();
3469     }
3470     QList<QGraphicsItem *> itemList = scene()->selectedItems();
3471     if (itemList.count() == 0) {
3472         emit displayMessage(i18n("Select a clip before copying"), ErrorMessage);
3473         return;
3474     }
3475     for (int i = 0; i < itemList.count(); i++) {
3476         if (itemList.at(i)->type() == AVWIDGET) {
3477             ClipItem *dup = static_cast <ClipItem *>(itemList.at(i));
3478             m_copiedItems.append(dup->clone(dup->info()));
3479         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
3480             Transition *dup = static_cast <Transition *>(itemList.at(i));
3481             m_copiedItems.append(dup->clone());
3482         }
3483     }
3484 }
3485
3486 bool CustomTrackView::canBePastedTo(ItemInfo info, int type) const {
3487     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));
3488     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
3489     for (int i = 0; i < collisions.count(); i++) {
3490         if (collisions.at(i)->type() == type) return false;
3491     }
3492     return true;
3493 }
3494
3495 bool CustomTrackView::canBePasted(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const {
3496     for (int i = 0; i < items.count(); i++) {
3497         ItemInfo info = items.at(i)->info();
3498         info.startPos += offset;
3499         info.endPos += offset;
3500         info.track += trackOffset;
3501         if (!canBePastedTo(info, items.at(i)->type())) return false;
3502     }
3503     return true;
3504 }
3505
3506 bool CustomTrackView::canBeMoved(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const {
3507     QPainterPath movePath;
3508     movePath.moveTo(0, 0);
3509
3510     for (int i = 0; i < items.count(); i++) {
3511         ItemInfo info = items.at(i)->info();
3512         info.startPos = info.startPos + offset;
3513         info.endPos = info.endPos + offset;
3514         info.track = info.track + trackOffset;
3515         if (info.startPos < GenTime()) {
3516             // No clip should go below 0
3517             return false;
3518         }
3519         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));
3520         movePath.addRect(rect);
3521     }
3522     QList<QGraphicsItem *> collisions = scene()->items(movePath, Qt::IntersectsItemBoundingRect);
3523     for (int i = 0; i < collisions.count(); i++) {
3524         if ((collisions.at(i)->type() == AVWIDGET || collisions.at(i)->type() == TRANSITIONWIDGET) && !items.contains(static_cast <AbstractClipItem *>(collisions.at(i)))) {
3525             kDebug() << "  ////////////   CLIP COLLISION, MOVE NOT ALLOWED";
3526             return false;
3527         }
3528     }
3529     return true;
3530 }
3531
3532 void CustomTrackView::pasteClip() {
3533     if (m_copiedItems.count() == 0) {
3534         emit displayMessage(i18n("No clip copied"), ErrorMessage);
3535         return;
3536     }
3537     QPoint position;
3538     if (m_menuPosition.isNull()) {
3539         position = mapFromGlobal(QCursor::pos());
3540         if (!underMouse() || position.y() > m_tracksHeight * m_document->tracksCount()) {
3541             emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
3542             return;
3543         }
3544     } else position = m_menuPosition;
3545     GenTime pos = GenTime((int)(mapToScene(position).x()), m_document->fps());
3546     int track = (int)(position.y() / m_tracksHeight);
3547     ItemInfo first = m_copiedItems.at(0)->info();
3548
3549     GenTime offset = pos - first.startPos;
3550     int trackOffset = track - first.track;
3551
3552     if (!canBePasted(m_copiedItems, offset, trackOffset)) {
3553         emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
3554         return;
3555     }
3556     QUndoCommand *pasteClips = new QUndoCommand();
3557     pasteClips->setText("Paste clips");
3558
3559     for (int i = 0; i < m_copiedItems.count(); i++) {
3560         // parse all clip names
3561         if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == AVWIDGET) {
3562             ClipItem *clip = static_cast <ClipItem *>(m_copiedItems.at(i));
3563             ItemInfo info;
3564             info.startPos = clip->startPos() + offset;
3565             info.endPos = clip->endPos() + offset;
3566             info.cropStart = clip->cropStart();
3567             info.track = clip->track() + trackOffset;
3568             if (canBePastedTo(info, AVWIDGET)) {
3569                 new AddTimelineClipCommand(this, clip->xml(), clip->clipProducer(), info, clip->effectList(), true, false, pasteClips);
3570             } else emit displayMessage(i18n("Cannot paste clip to selected place"), ErrorMessage);
3571         } else if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == TRANSITIONWIDGET) {
3572             Transition *tr = static_cast <Transition *>(m_copiedItems.at(i));
3573             ItemInfo info;
3574             info.startPos = tr->startPos() + offset;
3575             info.endPos = tr->endPos() + offset;
3576             info.track = tr->track() + trackOffset;
3577             if (canBePastedTo(info, TRANSITIONWIDGET)) {
3578                 if (info.startPos >= info.endPos) {
3579                     emit displayMessage(i18n("Invalid transition"), ErrorMessage);
3580                 } else new AddTransitionCommand(this, info, tr->transitionEndTrack() + trackOffset, tr->toXML(), false, true, pasteClips);
3581             } else emit displayMessage(i18n("Cannot paste transition to selected place"), ErrorMessage);
3582         }
3583     }
3584     m_commandStack->push(pasteClips);
3585 }
3586
3587 void CustomTrackView::pasteClipEffects() {
3588     if (m_copiedItems.count() != 1 || m_copiedItems.at(0)->type() != AVWIDGET) {
3589         emit displayMessage(i18n("You must copy exactly one clip before pasting effects"), ErrorMessage);
3590         return;
3591     }
3592     ClipItem *clip = static_cast < ClipItem *>(m_copiedItems.at(0));
3593     EffectsList effects = clip->effectList();
3594
3595     QUndoCommand *paste = new QUndoCommand();
3596     paste->setText("Paste effects");
3597
3598     QList<QGraphicsItem *> clips = scene()->selectedItems();
3599     for (int i = 0; i < clips.count(); ++i) {
3600         if (clips.at(i)->type() == AVWIDGET) {
3601             ClipItem *item = static_cast < ClipItem *>(clips.at(i));
3602             for (int i = 0; i < clip->effectsCount(); i++) {
3603                 new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), clip->effectAt(i), true, paste);
3604             }
3605         }
3606     }
3607     m_commandStack->push(paste);
3608 }
3609
3610
3611 ClipItem *CustomTrackView::getClipUnderCursor() const {
3612     QRectF rect((double) m_cursorPos, 0.0, 1.0, (double)(m_tracksHeight * m_document->tracksCount()));
3613     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
3614     for (int i = 0; i < collisions.count(); i++) {
3615         if (collisions.at(i)->type() == AVWIDGET) {
3616             return static_cast < ClipItem *>(collisions.at(i));
3617         }
3618     }
3619     return NULL;
3620 }
3621
3622 ClipItem *CustomTrackView::getMainActiveClip() const {
3623     QList<QGraphicsItem *> clips = scene()->selectedItems();
3624     if (clips.isEmpty()) {
3625         return getClipUnderCursor();
3626     } else {
3627         ClipItem *item = NULL;
3628         for (int i = 0; i < clips.count(); ++i) {
3629             if (clips.at(i)->type() == AVWIDGET)
3630                 item = static_cast < ClipItem *>(clips.at(i));
3631             if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos) break;
3632         }
3633         if (item) return item;
3634     }
3635     return NULL;
3636 }
3637
3638 ClipItem *CustomTrackView::getActiveClipUnderCursor(bool allowOutsideCursor) const {
3639     QList<QGraphicsItem *> clips = scene()->selectedItems();
3640     if (clips.isEmpty()) {
3641         return getClipUnderCursor();
3642     } else {
3643         ClipItem *item;
3644         // remove all items in the list that are not clips
3645         for (int i = 0; i < clips.count();) {
3646             if (clips.at(i)->type() != AVWIDGET) clips.removeAt(i);
3647             else i++;
3648         }
3649         if (clips.count() == 1 && allowOutsideCursor) return static_cast < ClipItem *>(clips.at(0));
3650         for (int i = 0; i < clips.count(); ++i) {
3651             if (clips.at(i)->type() == AVWIDGET) {
3652                 item = static_cast < ClipItem *>(clips.at(i));
3653                 if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos)
3654                     return item;
3655             }
3656         }
3657     }
3658     return NULL;
3659 }
3660
3661 void CustomTrackView::setInPoint() {
3662     ClipItem *clip = getActiveClipUnderCursor(true);
3663     if (clip == NULL) {
3664         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
3665         return;
3666     }
3667     ItemInfo startInfo = clip->info();
3668     ItemInfo endInfo = startInfo;
3669     endInfo.startPos = GenTime(m_cursorPos, m_document->fps());
3670     if (endInfo.startPos >= startInfo.endPos) {
3671         // Check for invalid resize
3672         emit displayMessage(i18n("Invalid action"), ErrorMessage);
3673         return;
3674     } else if (endInfo.startPos < startInfo.startPos) {
3675         int length = m_document->renderer()->mltGetSpaceLength(endInfo.startPos, m_document->tracksCount() - startInfo.track, false);
3676         if (length < (startInfo.startPos - endInfo.startPos).frames(m_document->fps())) {
3677             emit displayMessage(i18n("Invalid action"), ErrorMessage);
3678             return;
3679         }
3680     }
3681     ResizeClipCommand *command = new ResizeClipCommand(this, startInfo, endInfo, true);
3682     m_commandStack->push(command);
3683 }
3684
3685 void CustomTrackView::setOutPoint() {
3686     ClipItem *clip = getActiveClipUnderCursor(true);
3687     if (clip == NULL) {
3688         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
3689         return;
3690     }
3691     ItemInfo startInfo = clip->info();
3692     ItemInfo endInfo = clip->info();
3693     endInfo.endPos = GenTime(m_cursorPos, m_document->fps());
3694     if (endInfo.endPos <= startInfo.startPos) {
3695         // Check for invalid resize
3696         emit displayMessage(i18n("Invalid action"), ErrorMessage);
3697         return;
3698     } else if (endInfo.endPos > startInfo.endPos) {
3699         int length = m_document->renderer()->mltGetSpaceLength(endInfo.endPos, m_document->tracksCount() - startInfo.track, false);
3700         if (length < (endInfo.endPos - startInfo.endPos).frames(m_document->fps())) {
3701             emit displayMessage(i18n("Invalid action"), ErrorMessage);
3702             return;
3703         }
3704     }
3705
3706
3707
3708     ResizeClipCommand *command = new ResizeClipCommand(this, startInfo, endInfo, true);
3709     m_commandStack->push(command);
3710 }
3711
3712 void CustomTrackView::slotUpdateAllThumbs() {
3713     QList<QGraphicsItem *> itemList = items();
3714     //if (itemList.isEmpty()) return;
3715     ClipItem *item;
3716     QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
3717     for (int i = 0; i < itemList.count(); i++) {
3718         if (itemList.at(i)->type() == AVWIDGET) {
3719             item = static_cast <ClipItem *>(itemList.at(i));
3720             if (item->clipType() != COLOR) {
3721                 // Check if we have a cached thumbnail
3722                 if (item->clipType() == IMAGE || item->clipType() == TEXT || item->clipType() == AUDIO) {
3723                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
3724                     if (QFile::exists(thumb)) {
3725                         QPixmap pix(thumb);
3726                         item->slotSetStartThumb(pix);
3727                         item->slotSetEndThumb(pix);
3728                     }
3729                 } else {
3730                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
3731                     QString endThumb = startThumb;
3732                     startThumb.append(QString::number(item->cropStart().frames(m_document->fps())) + ".png");
3733                     endThumb.append(QString::number((item->cropStart() + item->cropDuration()).frames(m_document->fps()) - 1) + ".png");
3734                     if (QFile::exists(startThumb)) {
3735                         QPixmap pix(startThumb);
3736                         item->slotSetStartThumb(pix);
3737                     }
3738                     if (QFile::exists(endThumb)) {
3739                         QPixmap pix(endThumb);
3740                         item->slotSetEndThumb(pix);
3741                     }
3742                 }
3743             }
3744             item->refreshClip();
3745             qApp->processEvents();
3746         }
3747     }
3748     viewport()->update();
3749 }
3750
3751 void CustomTrackView::saveThumbnails() {
3752     QList<QGraphicsItem *> itemList = items();
3753     ClipItem *item;
3754     QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
3755     for (int i = 0; i < itemList.count(); i++) {
3756         if (itemList.at(i)->type() == AVWIDGET) {
3757             item = static_cast <ClipItem *>(itemList.at(i));
3758             if (item->clipType() != COLOR) {
3759                 // Check if we have a cached thumbnail
3760                 if (item->clipType() == IMAGE || item->clipType() == TEXT || item->clipType() == AUDIO) {
3761                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
3762                     if (!QFile::exists(thumb)) {
3763                         QPixmap pix(item->startThumb());
3764                         pix.save(thumb);
3765                     }
3766                 } else {
3767                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
3768                     QString endThumb = startThumb;
3769                     startThumb.append(QString::number(item->cropStart().frames(m_document->fps())) + ".png");
3770                     endThumb.append(QString::number((item->cropStart() + item->cropDuration()).frames(m_document->fps()) - 1) + ".png");
3771                     if (!QFile::exists(startThumb)) {
3772                         QPixmap pix(item->startThumb());
3773                         pix.save(startThumb);
3774                     }
3775                     if (!QFile::exists(endThumb)) {
3776                         QPixmap pix(item->endThumb());
3777                         pix.save(endThumb);
3778                     }
3779                 }
3780             }
3781         }
3782     }
3783 }
3784
3785
3786 void CustomTrackView::slotInsertTrack(int ix) {
3787     kDebug() << "// INSERTING TRK: " << ix;
3788     QDialog d(parentWidget());
3789     Ui::AddTrack_UI view;
3790     view.setupUi(&d);
3791     view.track_nb->setMaximum(m_document->tracksCount() - 1);
3792     view.track_nb->setValue(ix);
3793     d.setWindowTitle(i18n("Insert Track"));
3794
3795     if (d.exec() == QDialog::Accepted) {
3796         ix = view.track_nb->value();
3797         if (view.before_select->currentIndex() == 1) {
3798             ix++;
3799         }
3800         TrackInfo info;
3801         if (view.video_track->isChecked()) {
3802             info.type = VIDEOTRACK;
3803             info.isMute = false;
3804             info.isBlind = false;
3805             info.isLocked = false;
3806         } else {
3807             info.type = AUDIOTRACK;
3808             info.isMute = false;
3809             info.isBlind = true;
3810             info.isLocked = false;
3811         }
3812         AddTrackCommand *addTrack = new AddTrackCommand(this, ix, info, true, true);
3813         m_commandStack->push(addTrack);
3814         m_document->setModified(true);
3815     }
3816 }
3817
3818 void CustomTrackView::slotDeleteTrack(int ix) {
3819     bool ok;
3820     ix = QInputDialog::getInteger(this, i18n("Remove Track"), i18n("Track"), ix, 0, m_document->tracksCount() - 1, 1, &ok);
3821     if (ok) {
3822         TrackInfo info = m_document->trackInfoAt(m_document->tracksCount() - ix - 1);
3823         deleteTimelineTrack(ix, info);
3824         m_document->setModified(true);
3825         /*AddTrackCommand* command = new AddTrackCommand(this, ix, info, false, true);
3826         m_commandStack->push(command);*/
3827     }
3828 }
3829
3830 void CustomTrackView::slotChangeTrack(int ix) {
3831     QDialog d(parentWidget());
3832     Ui::AddTrack_UI view;
3833     view.setupUi(&d);
3834     view.label->setText(i18n("Change track"));
3835     view.before_select->setHidden(true);
3836     view.track_nb->setMaximum(m_document->tracksCount() - 1);
3837     view.track_nb->setValue(ix);
3838     d.setWindowTitle(i18n("Change Track Type"));
3839
3840     if (d.exec() == QDialog::Accepted) {
3841         TrackInfo info;
3842         info.isLocked = false;
3843         info.isMute = false;
3844         ix = view.track_nb->value();
3845
3846         if (view.video_track->isChecked()) {
3847             info.type = VIDEOTRACK;
3848             info.isBlind = false;
3849         } else {
3850             info.type = AUDIOTRACK;
3851             info.isBlind = true;
3852         }
3853         changeTimelineTrack(ix, info);
3854         m_document->setModified(true);
3855     }
3856 }
3857
3858
3859 void CustomTrackView::deleteTimelineTrack(int ix, TrackInfo trackinfo) {
3860     double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
3861     QRectF r(0, startY, sceneRect().width(), m_tracksHeight / 2 - 1);
3862     QList<QGraphicsItem *> selection = m_scene->items(r);
3863     QUndoCommand *deleteTrack = new QUndoCommand();
3864     deleteTrack->setText("Delete track");
3865
3866     // Delete all clips in selected track
3867     for (int i = 0; i < selection.count(); i++) {
3868         if (selection.at(i)->type() == AVWIDGET) {
3869             ClipItem *item =  static_cast <ClipItem *>(selection.at(i));
3870             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, true, deleteTrack);
3871             m_scene->removeItem(item);
3872             delete item;
3873             item = NULL;
3874         } else if (selection.at(i)->type() == TRANSITIONWIDGET) {
3875             Transition *item =  static_cast <Transition *>(selection.at(i));
3876             new AddTransitionCommand(this, item->info(), item->transitionEndTrack(), item->toXML(), true, false, deleteTrack);
3877             m_scene->removeItem(item);
3878             delete item;
3879             item = NULL;
3880         }
3881     }
3882
3883     new AddTrackCommand(this, ix, trackinfo, false, true, deleteTrack);
3884     m_commandStack->push(deleteTrack);
3885 }
3886
3887 void CustomTrackView::changeTimelineTrack(int ix, TrackInfo trackinfo) {
3888     TrackInfo oldinfo = m_document->trackInfoAt(m_document->tracksCount() - ix - 1);
3889     ChangeTrackCommand *changeTrack = new ChangeTrackCommand(this, ix, oldinfo, trackinfo, true);
3890     m_commandStack->push(changeTrack);
3891 }
3892
3893 void CustomTrackView::autoTransition() {
3894     QList<QGraphicsItem *> itemList = scene()->selectedItems();
3895     if (itemList.count() != 1 || itemList.at(0)->type() != TRANSITIONWIDGET) {
3896         emit displayMessage(i18n("You must select one transition for this action"), ErrorMessage);
3897         return;
3898     }
3899     Transition *tr = static_cast <Transition*>(itemList.at(0));
3900     tr->setAutomatic(!tr->isAutomatic());
3901     QDomElement transition = tr->toXML();
3902     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);
3903 }
3904
3905
3906 QStringList CustomTrackView::getLadspaParams(QDomElement effect) const {
3907     QStringList result;
3908     QDomNodeList params = effect.elementsByTagName("parameter");
3909     for (int i = 0; i < params.count(); i++) {
3910         QDomElement e = params.item(i).toElement();
3911         if (!e.isNull() && e.attribute("type") == "constant") {
3912             if (e.hasAttribute("factor")) {
3913                 double factor = e.attribute("factor").toDouble();
3914                 double value = e.attribute("value").toDouble();
3915                 value = value / factor;
3916                 result.append(QString::number(value));
3917             } else result.append(e.attribute("value"));
3918         }
3919     }
3920     return result;
3921 }
3922
3923 void CustomTrackView::clipNameChanged(const QString id, const QString name) {
3924     QList<QGraphicsItem *> list = scene()->items();
3925     ClipItem *clip = NULL;
3926     for (int i = 0; i < list.size(); ++i) {
3927         if (list.at(i)->type() == AVWIDGET) {
3928             clip = static_cast <ClipItem *>(list.at(i));
3929             if (clip->clipProducer() == id) {
3930                 clip->setClipName(name);
3931             }
3932         }
3933     }
3934     viewport()->update();
3935 }
3936
3937 void CustomTrackView::getClipAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum) {
3938     minimum = GenTime();
3939     maximum = GenTime();
3940     QList<QGraphicsItem *> selection;
3941     selection = m_scene->items(0, item->track() * m_tracksHeight + m_tracksHeight / 2, sceneRect().width(), 2);
3942     selection.removeAll(item);
3943     for (int i = 0; i < selection.count(); i++) {
3944         AbstractClipItem *clip = static_cast <AbstractClipItem *>(selection.at(i));
3945         if (clip && clip->type() == AVWIDGET) {
3946             if (clip->endPos() <= item->startPos() && clip->endPos() > minimum) minimum = clip->endPos();
3947             if (clip->startPos() > item->startPos() && (clip->startPos() < maximum || maximum == GenTime())) maximum = clip->startPos();
3948         }
3949     }
3950 }
3951
3952 void CustomTrackView::getTransitionAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum) {
3953     minimum = GenTime();
3954     maximum = GenTime();
3955     QList<QGraphicsItem *> selection;
3956     selection = m_scene->items(0, (item->track() + 1) * m_tracksHeight, sceneRect().width(), 2);
3957     selection.removeAll(item);
3958     for (int i = 0; i < selection.count(); i++) {
3959         AbstractClipItem *clip = static_cast <AbstractClipItem *>(selection.at(i));
3960         if (clip && clip->type() == TRANSITIONWIDGET) {
3961             if (clip->endPos() <= item->startPos() && clip->endPos() > minimum) minimum = clip->endPos();
3962             if (clip->startPos() > item->startPos() && (clip->startPos() < maximum || maximum == GenTime())) maximum = clip->startPos();
3963         }
3964     }
3965 }
3966
3967
3968 void CustomTrackView::loadGroups(const QDomNodeList groups) {
3969     for (int i = 0; i < groups.count(); i++) {
3970         QDomNodeList children = groups.at(i).childNodes();
3971         scene()->clearSelection();
3972         for (int nodeindex = 0; nodeindex < children.count(); nodeindex++) {
3973             QDomNode n = children.item(nodeindex);
3974             QDomElement elem = n.toElement();
3975             int pos = elem.attribute("position").toInt();
3976             int track = elem.attribute("track").toInt();
3977             if (elem.tagName() == "clipitem") {
3978                 ClipItem *clip = getClipItemAt(pos, track); //m_document->tracksCount() - transitiontrack);
3979                 if (clip) clip->setSelected(true);
3980             } else {
3981                 Transition *clip = getTransitionItemAt(pos, track); //m_document->tracksCount() - transitiontrack);
3982                 if (clip) clip->setSelected(true);
3983             }
3984         }
3985         groupSelectedItems(false, true);
3986     }
3987 }
3988
3989 #include "customtrackview.moc"