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                 QGraphicsItemGroup *group = static_cast <QGraphicsItemGroup *>(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                 scene()->destroyItemGroup(group);
 833                 if (!selection.isEmpty()) {
 834                     QPointF top = selection.at(0)->sceneBoundingRect().topLeft();
 835
 836                     // Find top left position of selection
 837                     for (int j = 1; j < selection.count(); j++) {
 838                         if (selection.at(j)->type() == AVWIDGET || selection.at(j)->type() == TRANSITIONWIDGET) {
 839                             selection.at(j)->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
 840                             QPointF currenttop = selection.at(j)->sceneBoundingRect().topLeft();
 841                             //kDebug()<<"// GRP ITEM POS:"<<currenttop;
 842                             if (currenttop.x() < top.x()) top.setX(currenttop.x());
 843                             if (currenttop.y() < top.y()) top.setY(currenttop.y());
 844                         }
 845                     }
 846
 847                     AbstractGroupItem *newGroup = new AbstractGroupItem(m_document->fps());
 848                     newGroup->translate(-top.x(), -top.y() + 1);
 849                     newGroup->setPos(top.x(), top.y() - 1);
 850                     scene()->addItem(newGroup);
 851
 852                     for (int j = 0; j < selection.count(); j++) {
 853                         if (selection.at(j)->type() == AVWIDGET || selection.at(j)->type() == TRANSITIONWIDGET) {
 854                             newGroup->addToGroup(selection.at(j));
 855                             //kDebug()<<"// ADDING ITEM:"<<selection.at(j)->sceneBoundingRect();
 856                             selection.at(j)->setFlags(QGraphicsItem::ItemIsSelectable);
 857                         }
 858                     }
 859                 }
 860             }
 861         }
 862         m_selectionGroup = NULL;
 863         KdenliveSettings::setSnaptopoints(snap);
 864     }
 865 }
 866
 867 void CustomTrackView::groupSelectedItems(bool force, bool createNewGroup) {
 868     if (m_selectionGroup) {
 869         kDebug() << "///// ERROR, TRYING TO OVERRIDE EXISTING GROUP";
 870         return;
 871     }
 872     QList<QGraphicsItem *> selection = m_scene->selectedItems();
 873     if (selection.isEmpty()) return;
 874     QPointF top = selection.at(0)->sceneBoundingRect().topLeft();
 875     // Find top left position of selection
 876     for (int i = 1; i < selection.count(); i++) {
 877         if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET) {
 878             QPointF currenttop = selection.at(i)->sceneBoundingRect().topLeft();
 879             if (currenttop.x() < top.x()) top.setX(currenttop.x());
 880             if (currenttop.y() < top.y()) top.setY(currenttop.y());
 881         }
 882     }
 883
 884     if (force || selection.count() > 1) {
 885         bool snap = KdenliveSettings::snaptopoints();
 886         KdenliveSettings::setSnaptopoints(false);
 887         if (createNewGroup) {
 888             AbstractGroupItem *newGroup = new AbstractGroupItem(m_document->fps());
 889             newGroup->translate(-top.x(), -top.y() + 1);
 890             newGroup->setPos(top.x(), top.y() - 1);
 891             scene()->addItem(newGroup);
 892
 893             // CHeck if we are trying to include a group in a group
 894             QList <QGraphicsItemGroup *> groups;
 895             for (int i = 0; i < selection.count(); i++) {
 896                 if (selection.at(i)->type() == GROUPWIDGET && !groups.contains(static_cast<QGraphicsItemGroup *>(selection.at(i)))) {
 897                     groups.append(static_cast<QGraphicsItemGroup *>(selection.at(i)));
 898                 } else if (selection.at(i)->parentItem() && !groups.contains(static_cast<QGraphicsItemGroup *>(selection.at(i)->parentItem()))) groups.append(static_cast<QGraphicsItemGroup *>(selection.at(i)->parentItem()));
 899             }
 900             if (!groups.isEmpty()) {
 901                 // ungroup previous groups
 902                 while (!groups.isEmpty()) {
 903                     QGraphicsItemGroup *grp = groups.takeFirst();
 904                     scene()->destroyItemGroup(grp);
 905                 }
 906                 selection = m_scene->selectedItems();
 907             }
 908
 909             for (int i = 0; i < selection.count(); i++) {
 910                 if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET) {
 911                     newGroup->addToGroup(selection.at(i));
 912                     selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
 913                 }
 914             }
 915             syncGroups();
 916             KdenliveSettings::setSnaptopoints(snap);
 917         } else {
 918             m_selectionGroup = new AbstractGroupItem(m_document->fps());
 919             m_selectionGroup->translate(-top.x(), -top.y() + 1);
 920             m_selectionGroup->setPos(top.x(), top.y() - 1);
 921             scene()->addItem(m_selectionGroup);
 922             for (int i = 0; i < selection.count(); i++) {
 923                 if (selection.at(i)->parentItem() == NULL && (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET || selection.at(i)->type() == GROUPWIDGET)) {
 924                     m_selectionGroup->addToGroup(selection.at(i));
 925                     selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
 926                 }
 927             }
 928             KdenliveSettings::setSnaptopoints(snap);
 929             if (m_selectionGroup) {
 930                 m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
 931                 m_selectionGroupInfo.track = m_selectionGroup->track();
 932             }
 933         }
 934     } else resetSelectionGroup();
 935 }
 936
 937 void CustomTrackView::mouseDoubleClickEvent(QMouseEvent *event) {
 938     kDebug() << "++++++++++++ DBL CLK";
 939     if (m_dragItem && m_dragItem->hasKeyFrames()) {
 940         if (m_moveOpMode == KEYFRAME) {
 941             // user double clicked on a keyframe, open edit dialog
 942             QDialog d(parentWidget());
 943             Ui::KeyFrameDialog_UI view;
 944             view.setupUi(&d);
 945             view.kfr_position->setText(m_document->timecode().getTimecode(GenTime(m_dragItem->selectedKeyFramePos(), m_document->fps()) - m_dragItem->cropStart(), m_document->fps()));
 946             view.kfr_value->setValue(m_dragItem->selectedKeyFrameValue());
 947             view.kfr_value->setFocus();
 948             if (d.exec() == QDialog::Accepted) {
 949                 int pos = m_document->timecode().getFrameCount(view.kfr_position->text(), m_document->fps());
 950                 m_dragItem->updateKeyFramePos(GenTime(pos, m_document->fps()) + m_dragItem->cropStart(), (double) view.kfr_value->value() * m_dragItem->keyFrameFactor());
 951                 ClipItem *item = (ClipItem *)m_dragItem;
 952                 QString previous = item->keyframes(item->selectedEffectIndex());
 953                 item->updateKeyframeEffect();
 954                 QString next = item->keyframes(item->selectedEffectIndex());
 955                 EditKeyFrameCommand *command = new EditKeyFrameCommand(this, item->track(), item->startPos(), item->selectedEffectIndex(), previous, next, false);
 956                 m_commandStack->push(command);
 957                 updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
 958             }
 959
 960         } else  {
 961             // add keyframe
 962             GenTime keyFramePos = GenTime((int)(mapToScene(event->pos()).x()), m_document->fps()) - m_dragItem->startPos() + m_dragItem->cropStart();
 963             m_dragItem->addKeyFrame(keyFramePos, mapToScene(event->pos()).toPoint().y());
 964             ClipItem * item = (ClipItem *) m_dragItem;
 965             QString previous = item->keyframes(item->selectedEffectIndex());
 966             item->updateKeyframeEffect();
 967             QString next = item->keyframes(item->selectedEffectIndex());
 968             EditKeyFrameCommand *command = new EditKeyFrameCommand(this, m_dragItem->track(), m_dragItem->startPos(), item->selectedEffectIndex(), previous, next, false);
 969             m_commandStack->push(command);
 970             updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
 971         }
 972     } else if (m_dragItem) {
 973         ClipDurationDialog d(m_dragItem, m_document->timecode(), this);
 974         GenTime minimum;
 975         GenTime maximum;
 976         if (m_dragItem->type() == TRANSITIONWIDGET) {
 977             getTransitionAvailableSpace(m_dragItem, minimum, maximum);
 978         } else {
 979             getClipAvailableSpace(m_dragItem, minimum, maximum);
 980         }
 981         //kDebug()<<"// GOT MOVE POS: "<<minimum.frames(25)<<" - "<<maximum.frames(25);
 982         d.setMargins(minimum, maximum);
 983         if (d.exec() == QDialog::Accepted) {
 984             if (m_dragItem->type() == TRANSITIONWIDGET) {
 985                 // move & resize transition
 986                 ItemInfo startInfo;
 987                 startInfo.startPos = m_dragItem->startPos();
 988                 startInfo.endPos = m_dragItem->endPos();
 989                 startInfo.track = m_dragItem->track();
 990                 ItemInfo endInfo;
 991                 endInfo.startPos = d.startPos();
 992                 endInfo.endPos = endInfo.startPos + d.duration();
 993                 endInfo.track = m_dragItem->track();
 994                 MoveTransitionCommand *command = new MoveTransitionCommand(this, startInfo, endInfo, true);
 995                 m_commandStack->push(command);
 996             } else {
 997                 // move and resize clip
 998                 QUndoCommand *moveCommand = new QUndoCommand();
 999                 moveCommand->setText(i18n("Edit clip"));
1000                 ItemInfo clipInfo = m_dragItem->info();
1001                 if (d.startPos() != clipInfo.startPos) {
1002                     ItemInfo startInfo = clipInfo;
1003                     clipInfo.startPos = d.startPos();
1004                     clipInfo.endPos = m_dragItem->endPos() + (clipInfo.startPos - startInfo.startPos);
1005                     new MoveClipCommand(this, startInfo, clipInfo, true, moveCommand);
1006                 }
1007                 if (d.duration() != m_dragItem->duration() || d.cropStart() != clipInfo.cropStart) {
1008                     ItemInfo startInfo = clipInfo;
1009                     clipInfo.endPos = clipInfo.startPos + d.duration();
1010                     clipInfo.cropStart = d.cropStart();
1011                     new ResizeClipCommand(this, startInfo, clipInfo, true, moveCommand);
1012                 }
1013                 m_commandStack->push(moveCommand);
1014             }
1015         }
1016     } else {
1017         QList<QGraphicsItem *> collisionList = items(event->pos());
1018         if (collisionList.count() == 1 && collisionList.at(0)->type() == GUIDEITEM) {
1019             Guide *editGuide = (Guide *) collisionList.at(0);
1020             if (editGuide) slotEditGuide(editGuide->info());
1021         }
1022     }
1023 }
1024
1025
1026 void CustomTrackView::editKeyFrame(const GenTime pos, const int track, const int index, const QString keyframes) {
1027     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()), track);
1028     if (clip) {
1029         clip->setKeyframes(index, keyframes);
1030         updateEffect(m_document->tracksCount() - clip->track(), clip->startPos(), clip->effectAt(index), index);
1031     } else emit displayMessage(i18n("Cannot find clip with keyframe"), ErrorMessage);
1032 }
1033
1034
1035 void CustomTrackView::displayContextMenu(QPoint pos, AbstractClipItem *clip, AbstractGroupItem *group) {
1036     if (clip == NULL) m_timelineContextMenu->popup(pos);
1037     else if (group != NULL) {
1038         m_changeSpeedAction->setEnabled(false);
1039         m_pasteEffectsAction->setEnabled(m_copiedItems.count() == 1);
1040         m_ungroupAction->setEnabled(true);
1041         m_timelineContextClipMenu->popup(pos);
1042     } else {
1043         m_ungroupAction->setEnabled(false);
1044         if (clip->type() == AVWIDGET) {
1045             ClipItem *item = static_cast <ClipItem*>(clip);
1046             m_changeSpeedAction->setEnabled(item->clipType() == AV || item->clipType() == VIDEO);
1047             m_pasteEffectsAction->setEnabled(m_copiedItems.count() == 1);
1048             m_timelineContextClipMenu->popup(pos);
1049         } else if (clip->type() == TRANSITIONWIDGET) m_timelineContextTransitionMenu->popup(pos);
1050     }
1051 }
1052
1053 void CustomTrackView::activateMonitor() {
1054     emit activateDocumentMonitor();
1055 }
1056
1057 void CustomTrackView::dragEnterEvent(QDragEnterEvent * event) {
1058     if (event->mimeData()->hasFormat("kdenlive/clip")) {
1059         m_clipDrag = true;
1060         resetSelectionGroup();
1061         QStringList list = QString(event->mimeData()->data("kdenlive/clip")).split(';');
1062         m_selectionGroup = new AbstractGroupItem(m_document->fps());
1063         QPoint pos = QPoint();
1064         DocClipBase *clip = m_document->getBaseClip(list.at(0));
1065         if (clip == NULL) kDebug() << " WARNING))))))))) CLIP NOT FOUND : " << list.at(0);
1066         ItemInfo info;
1067         info.startPos = GenTime();
1068         info.cropStart = GenTime(list.at(1).toInt(), m_document->fps());
1069         info.endPos = GenTime(list.at(2).toInt() - list.at(1).toInt(), m_document->fps());
1070         info.track = (int)(1 / m_tracksHeight);
1071         ClipItem *item = new ClipItem(clip, info, m_document->fps(), 1.0);
1072         m_selectionGroup->addToGroup(item);
1073         item->setFlags(QGraphicsItem::ItemIsSelectable);
1074         //TODO: check if we do not overlap another clip when first dropping in timeline
1075         // if (insertPossible(m_selectionGroup, event->pos()))
1076         QList <GenTime> offsetList;
1077         offsetList.append(info.endPos);
1078         updateSnapPoints(NULL, offsetList);
1079         scene()->addItem(m_selectionGroup);
1080         event->acceptProposedAction();
1081     } else if (event->mimeData()->hasFormat("kdenlive/producerslist")) {
1082         m_clipDrag = true;
1083         QStringList ids = QString(event->mimeData()->data("kdenlive/producerslist")).split(';');
1084         m_scene->clearSelection();
1085         resetSelectionGroup(false);
1086
1087         m_selectionGroup = new AbstractGroupItem(m_document->fps());
1088         QPoint pos = QPoint();
1089         GenTime start = GenTime();
1090         QList <GenTime> offsetList;
1091         for (int i = 0; i < ids.size(); ++i) {
1092             DocClipBase *clip = m_document->getBaseClip(ids.at(i));
1093             if (clip == NULL) kDebug() << " WARNING))))))))) CLIP NOT FOUND : " << ids.at(i);
1094             ItemInfo info;
1095             info.startPos = start;
1096             info.endPos = info.startPos + clip->duration();
1097             info.track = (int)(1 / m_tracksHeight);
1098             ClipItem *item = new ClipItem(clip, info, m_document->fps(), 1.0);
1099             start += clip->duration();
1100             offsetList.append(start);
1101             m_selectionGroup->addToGroup(item);
1102             item->setFlags(QGraphicsItem::ItemIsSelectable);
1103         }
1104         //TODO: check if we do not overlap another clip when first dropping in timeline
1105         //if (insertPossible(m_selectionGroup, event->pos()))
1106         updateSnapPoints(NULL, offsetList);
1107         scene()->addItem(m_selectionGroup);
1108         event->acceptProposedAction();
1109     } else {
1110         // the drag is not a clip (may be effect, ...)
1111         m_clipDrag = false;
1112         QGraphicsView::dragEnterEvent(event);
1113     }
1114 }
1115
1116
1117 bool CustomTrackView::insertPossible(AbstractGroupItem *group, const QPoint &pos) const {
1118     QPolygonF path;
1119     QList<QGraphicsItem *> children = group->childItems();
1120     for (int i = 0; i < children.count(); i++) {
1121         if (children.at(i)->type() == AVWIDGET) {
1122             ClipItem *clip = static_cast <ClipItem *>(children.at(i));
1123             ItemInfo info = clip->info();
1124             kDebug() << " / / INSERT : " << pos.x();
1125             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);
1126             kDebug() << " / / INSERT RECT: " << shape;
1127             path = path.united(QPolygonF(shape));
1128         }
1129     }
1130
1131     QList<QGraphicsItem*> collindingItems = scene()->items(path, Qt::IntersectsItemShape);
1132     if (collindingItems.isEmpty()) return true;
1133     else {
1134         for (int i = 0; i < collindingItems.count(); i++) {
1135             QGraphicsItem *collision = collindingItems.at(i);
1136             if (collision->type() == AVWIDGET) {
1137                 // Collision
1138                 kDebug() << "// COLLISIION DETECTED";
1139                 return false;
1140             }
1141         }
1142         return true;
1143     }
1144
1145 }
1146
1147 void CustomTrackView::slotRefreshEffects(ClipItem *clip) {
1148     int track = m_document->tracksCount() - clip->track();
1149     GenTime pos = clip->startPos();
1150     if (!m_document->renderer()->mltRemoveEffect(track, pos, "-1", false, false)) {
1151         emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
1152         return;
1153     }
1154     bool success = true;
1155     for (int i = 0; i < clip->effectsCount(); i++) {
1156         if (!m_document->renderer()->mltAddEffect(track, pos, clip->getEffectArgs(clip->effectAt(i)), false)) success = false;
1157     }
1158     if (!success) emit displayMessage(i18n("Problem adding effect to clip"), ErrorMessage);
1159     m_document->renderer()->doRefresh();
1160 }
1161
1162 void CustomTrackView::addEffect(int track, GenTime pos, QDomElement effect) {
1163     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1164     if (clip) {
1165         if (!m_document->renderer()->mltAddEffect(track, pos, clip->addEffect(effect)))
1166             emit displayMessage(i18n("Problem adding effect to clip"), ErrorMessage);
1167         emit clipItemSelected(clip);
1168     } else emit displayMessage(i18n("Cannot find clip to add effect"), ErrorMessage);
1169 }
1170
1171 void CustomTrackView::deleteEffect(int track, GenTime pos, QDomElement effect) {
1172     QString index = effect.attribute("kdenlive_ix");
1173     if (!m_document->renderer()->mltRemoveEffect(track, pos, index, true) && effect.attribute("disabled") != "1") {
1174         kDebug() << "// ERROR REMOV EFFECT: " << index << ", DISABLE: " << effect.attribute("disabled");
1175         emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
1176         return;
1177     }
1178     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1179     if (clip) {
1180         clip->deleteEffect(index);
1181         emit clipItemSelected(clip);
1182     }
1183 }
1184
1185 void CustomTrackView::slotAddGroupEffect(QDomElement effect, AbstractGroupItem *group) {
1186     QList<QGraphicsItem *> itemList = group->childItems();
1187     QUndoCommand *effectCommand = new QUndoCommand();
1188     QString effectName;
1189     QDomNode namenode = effect.elementsByTagName("name").item(0);
1190     if (!namenode.isNull()) effectName = i18n(namenode.toElement().text().toUtf8().data());
1191     else effectName = i18n("effect");
1192     effectCommand->setText(i18n("Add %1", effectName));
1193     int count = 0;
1194     for (int i = 0; i < itemList.count(); i++) {
1195         if (itemList.at(i)->type() == AVWIDGET) {
1196             ClipItem *item = (ClipItem *)itemList.at(i);
1197             if (item->hasEffect(effect.attribute("tag"), effect.attribute("id")) != -1 && effect.attribute("unique", "0") != "0") {
1198                 emit displayMessage(i18n("Effect already present in clip"), ErrorMessage);
1199                 continue;
1200             }
1201             if (item->isItemLocked()) {
1202                 continue;
1203             }
1204             item->initEffect(effect);
1205             if (effect.attribute("tag") == "ladspa") {
1206                 QString ladpsaFile = m_document->getLadspaFile();
1207                 initEffects::ladspaEffectFile(ladpsaFile, effect.attribute("ladspaid").toInt(), getLadspaParams(effect));
1208                 effect.setAttribute("src", ladpsaFile);
1209             }
1210             new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), effect, true, effectCommand);
1211             count++;
1212         }
1213     }
1214     if (count > 0) {
1215         m_commandStack->push(effectCommand);
1216         m_document->setModified(true);
1217     } else delete effectCommand;
1218 }
1219
1220 void CustomTrackView::slotAddEffect(QDomElement effect, GenTime pos, int track) {
1221     QList<QGraphicsItem *> itemList;
1222     QUndoCommand *effectCommand = new QUndoCommand();
1223     QString effectName;
1224     QDomNode namenode = effect.elementsByTagName("name").item(0);
1225     if (!namenode.isNull()) effectName = i18n(namenode.toElement().text().toUtf8().data());
1226     else effectName = i18n("effect");
1227     effectCommand->setText(i18n("Add %1", effectName));
1228     int count = 0;
1229     if (track == -1) itemList = scene()->selectedItems();
1230     if (itemList.isEmpty()) {
1231         ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, track);
1232         if (clip) itemList.append(clip);
1233         else emit displayMessage(i18n("Select a clip if you want to apply an effect"), ErrorMessage);
1234     }
1235     kDebug() << "// REQUESTING EFFECT ON CLIP: " << pos.frames(25) << ", TRK: " << track << "SELECTED ITEMS: " << itemList.count();
1236     for (int i = 0; i < itemList.count(); i++) {
1237         if (itemList.at(i)->type() == AVWIDGET) {
1238             ClipItem *item = (ClipItem *)itemList.at(i);
1239             if (item->hasEffect(effect.attribute("tag"), effect.attribute("id")) != -1 && effect.attribute("unique", "0") != "0") {
1240                 emit displayMessage(i18n("Effect already present in clip"), ErrorMessage);
1241                 continue;
1242             }
1243             if (item->isItemLocked()) {
1244                 continue;
1245             }
1246             item->initEffect(effect);
1247             if (effect.attribute("tag") == "ladspa") {
1248                 QString ladpsaFile = m_document->getLadspaFile();
1249                 initEffects::ladspaEffectFile(ladpsaFile, effect.attribute("ladspaid").toInt(), getLadspaParams(effect));
1250                 effect.setAttribute("src", ladpsaFile);
1251             }
1252             new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), effect, true, effectCommand);
1253             count++;
1254         }
1255     }
1256     if (count > 0) {
1257         m_commandStack->push(effectCommand);
1258         m_document->setModified(true);
1259     } else delete effectCommand;
1260 }
1261
1262 void CustomTrackView::slotDeleteEffect(ClipItem *clip, QDomElement effect) {
1263     AddEffectCommand *command = new AddEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), effect, false);
1264     m_commandStack->push(command);
1265     m_document->setModified(true);
1266 }
1267
1268 void CustomTrackView::updateEffect(int track, GenTime pos, QDomElement effect, int ix, bool triggeredByUser) {
1269     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1270     if (clip) {
1271         EffectsParameterList effectParams = clip->getEffectArgs(effect);
1272         if (effect.attribute("tag") == "ladspa") {
1273             // Update the ladspa affect file
1274             initEffects::ladspaEffectFile(effect.attribute("src"), effect.attribute("ladspaid").toInt(), getLadspaParams(effect));
1275         }
1276         // check if we are trying to reset a keyframe effect
1277         if (effectParams.hasParam("keyframes") && effectParams.paramValue("keyframes").isEmpty()) {
1278             clip->initEffect(effect);
1279             clip->setEffectAt(ix, effect);
1280             effectParams = clip->getEffectArgs(effect);
1281         }
1282         if (effectParams.paramValue("disabled") == "1") {
1283             if (m_document->renderer()->mltRemoveEffect(track, pos, effectParams.paramValue("kdenlive_ix"), false)) {
1284                 kDebug() << "//////  DISABLING EFFECT: " << ix << ", CURRENTLA: " << clip->selectedEffectIndex();
1285             } else emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
1286         } else if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - clip->track(), clip->startPos(), effectParams))
1287             emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
1288
1289         clip->setEffectAt(ix, effect);
1290         if (ix == clip->selectedEffectIndex()) {
1291             clip->setSelectedEffect(ix);
1292             if (!triggeredByUser) emit clipItemSelected(clip, ix);
1293         }
1294         if (effect.attribute("tag") == "volume" || effect.attribute("tag") == "brightness") {
1295             // A fade effect was modified, update the clip
1296             if (effect.attribute("id") == "fadein" || effect.attribute("id") == "fade_from_black") {
1297                 int pos = effectParams.paramValue("out").toInt() - effectParams.paramValue("in").toInt();
1298                 clip->setFadeIn(pos);
1299             }
1300             if (effect.attribute("id") == "fadeout" || effect.attribute("id") == "fade_to_black") {
1301                 int pos = effectParams.paramValue("out").toInt() - effectParams.paramValue("in").toInt();
1302                 clip->setFadeOut(pos);
1303             }
1304
1305         }
1306     }
1307     m_document->setModified(true);
1308 }
1309
1310 void CustomTrackView::moveEffect(int track, GenTime pos, int oldPos, int newPos) {
1311     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1312     if (clip) {
1313         m_document->renderer()->mltMoveEffect(track, pos, oldPos, newPos);
1314         QDomElement act = clip->effectAt(newPos - 1).cloneNode().toElement();
1315         QDomElement before = clip->effectAt(oldPos - 1).cloneNode().toElement();
1316         clip->setEffectAt(oldPos - 1, act);
1317         clip->setEffectAt(newPos - 1, before);
1318         emit clipItemSelected(clip, newPos - 1);
1319     }
1320     m_document->setModified(true);
1321 }
1322
1323 void CustomTrackView::slotChangeEffectState(ClipItem *clip, int effectPos, bool disable) {
1324     QDomElement effect = clip->effectAt(effectPos);
1325     QDomElement oldEffect = effect.cloneNode().toElement();
1326     effect.setAttribute("disabled", disable);
1327     EditEffectCommand *command = new EditEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), oldEffect, effect, effectPos, true);
1328     m_commandStack->push(command);
1329     m_document->setModified(true);
1330 }
1331
1332 void CustomTrackView::slotChangeEffectPosition(ClipItem *clip, int currentPos, int newPos) {
1333     MoveEffectCommand *command = new MoveEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), currentPos, newPos, true);
1334     m_commandStack->push(command);
1335     m_document->setModified(true);
1336 }
1337
1338 void CustomTrackView::slotUpdateClipEffect(ClipItem *clip, QDomElement oldeffect, QDomElement effect, int ix) {
1339     EditEffectCommand *command = new EditEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), oldeffect, effect, ix, true);
1340     m_commandStack->push(command);
1341 }
1342
1343 void CustomTrackView::cutClip(ItemInfo info, GenTime cutTime, bool cut) {
1344     if (cut) {
1345         // cut clip
1346         ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
1347         if (!item || cutTime >= item->endPos() || cutTime <= item->startPos()) {
1348             emit displayMessage(i18n("Cannot find clip to cut"), ErrorMessage);
1349             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);
1350             m_blockRefresh = false;
1351             return;
1352         }
1353         if (item->parentItem()) {
1354             // Item is part of a group, reset group
1355             resetSelectionGroup();
1356         }
1357         kDebug() << "/////////  CUTTING CLIP : (" << item->startPos().frames(25) << "-" << item->endPos().frames(25) << "), INFO: (" << info.startPos.frames(25) << "-" << info.endPos.frames(25) << ")" << ", CUT: " << cutTime.frames(25);
1358
1359         m_document->renderer()->mltCutClip(m_document->tracksCount() - info.track, cutTime);
1360         int cutPos = (int) cutTime.frames(m_document->fps());
1361         ItemInfo newPos;
1362         double speed = item->speed();
1363         newPos.startPos = cutTime;
1364         newPos.endPos = info.endPos;
1365         if (speed == 1) newPos.cropStart = item->info().cropStart + (cutTime - info.startPos);
1366         else newPos.cropStart = item->info().cropStart + (cutTime - info.startPos) * speed;
1367         newPos.track = info.track;
1368         ClipItem *dup = item->clone(newPos);
1369         item->resizeEnd(cutPos, false);
1370         scene()->addItem(dup);
1371         if (item->checkKeyFrames()) slotRefreshEffects(item);
1372         if (dup->checkKeyFrames()) slotRefreshEffects(dup);
1373         item->baseClip()->addReference();
1374         m_document->updateClip(item->baseClip()->getId());
1375         m_document->setModified(true);
1376         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);
1377         kDebug() << "//  CUTTING CLIP dONE";
1378     } else {
1379         // uncut clip
1380
1381         ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
1382         ClipItem *dup = getClipItemAt((int) cutTime.frames(m_document->fps()) + 1, info.track);
1383         if (!item || !dup || item == dup) {
1384             emit displayMessage(i18n("Cannot find clip to uncut"), ErrorMessage);
1385             m_blockRefresh = false;
1386             return;
1387         }
1388         if (m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, cutTime) == false) {
1389             emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(cutTime.frames(m_document->fps())), info.track), ErrorMessage);
1390             return;
1391         }
1392
1393         kDebug() << "// UNCUTTING CLIPS: ITEM 1 (" << item->startPos().frames(25) << "x" << item->endPos().frames(25) << ")";
1394         kDebug() << "// UNCUTTING CLIPS: ITEM 2 (" << dup->startPos().frames(25) << "x" << dup->endPos().frames(25) << ")";
1395         kDebug() << "// UNCUTTING CLIPS, INFO (" << info.startPos.frames(25) << "x" << info.endPos.frames(25) << ") , CUT: " << cutTime.frames(25);;
1396         //deleteClip(dup->info());
1397
1398
1399         if (dup->isSelected()) emit clipItemSelected(NULL);
1400         dup->baseClip()->removeReference();
1401         m_document->updateClip(dup->baseClip()->getId());
1402         scene()->removeItem(dup);
1403         delete dup;
1404
1405         ItemInfo clipinfo = item->info();
1406         clipinfo.track = m_document->tracksCount() - clipinfo.track;
1407         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, info.endPos - info.startPos);
1408         if (success) {
1409             item->resizeEnd((int) info.endPos.frames(m_document->fps()));
1410             m_document->setModified(true);
1411         } else
1412             emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
1413
1414     }
1415     QTimer::singleShot(3000, this, SLOT(slotEnableRefresh()));
1416 }
1417
1418 void CustomTrackView::slotEnableRefresh() {
1419     m_blockRefresh = false;
1420 }
1421
1422 void CustomTrackView::slotAddTransitionToSelectedClips(QDomElement transition) {
1423     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1424     if (itemList.count() == 1) {
1425         if (itemList.at(0)->type() == AVWIDGET) {
1426             ClipItem *item = (ClipItem *) itemList.at(0);
1427             ItemInfo info;
1428             info.track = item->track();
1429             ClipItem *transitionClip = NULL;
1430             const int transitiontrack = getPreviousVideoTrack(info.track);
1431             GenTime pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
1432             if (pos < item->startPos() + item->duration() / 2) {
1433                 // add transition to clip start
1434                 info.startPos = item->startPos();
1435                 if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.startPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
1436                 if (transitionClip && transitionClip->endPos() < item->endPos()) {
1437                     info.endPos = transitionClip->endPos();
1438                 } else info.endPos = info.startPos + GenTime(65, m_document->fps());
1439                 // Check there is no other transition at that place
1440                 double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
1441                 QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
1442                 QList<QGraphicsItem *> selection = m_scene->items(r);
1443                 bool transitionAccepted = true;
1444                 for (int i = 0; i < selection.count(); i++) {
1445                     if (selection.at(i)->type() == TRANSITIONWIDGET) {
1446                         Transition *tr = static_cast <Transition *>(selection.at(i));
1447                         if (tr->startPos() - info.startPos > GenTime(5, m_document->fps())) {
1448                             if (tr->startPos() < info.endPos) info.endPos = tr->startPos();
1449                         } else transitionAccepted = false;
1450                     }
1451                 }
1452                 if (transitionAccepted) slotAddTransition(item, info, transitiontrack, transition);
1453                 else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1454
1455             } else {
1456                 // add transition to clip  end
1457                 info.endPos = item->endPos();
1458                 if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.endPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
1459                 if (transitionClip && transitionClip->startPos() > item->startPos()) {
1460                     info.startPos = transitionClip->startPos();
1461                 } else info.startPos = info.endPos - GenTime(65, m_document->fps());
1462                 if (transition.attribute("tag") == "luma") EffectsList::setParameter(transition, "reverse", "1");
1463
1464                 // Check there is no other transition at that place
1465                 double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
1466                 QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
1467                 QList<QGraphicsItem *> selection = m_scene->items(r);
1468                 bool transitionAccepted = true;
1469                 for (int i = 0; i < selection.count(); i++) {
1470                     if (selection.at(i)->type() == TRANSITIONWIDGET) {
1471                         Transition *tr = static_cast <Transition *>(selection.at(i));
1472                         if (info.endPos - tr->endPos() > GenTime(5, m_document->fps())) {
1473                             if (tr->endPos() > info.startPos) info.startPos = tr->endPos();
1474                         } else transitionAccepted = false;
1475                     }
1476                 }
1477                 if (transitionAccepted) slotAddTransition(item, info, transitiontrack, transition);
1478                 else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1479             }
1480         }
1481     } else for (int i = 0; i < itemList.count(); i++) {
1482             if (itemList.at(i)->type() == AVWIDGET) {
1483                 ClipItem *item = (ClipItem *) itemList.at(i);
1484                 ItemInfo info;
1485                 info.startPos = item->startPos();
1486                 info.endPos = info.startPos + GenTime(65, m_document->fps());
1487                 info.track = item->track();
1488
1489                 // Check there is no other transition at that place
1490                 double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
1491                 QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
1492                 QList<QGraphicsItem *> selection = m_scene->items(r);
1493                 bool transitionAccepted = true;
1494                 for (int i = 0; i < selection.count(); i++) {
1495                     if (selection.at(i)->type() == TRANSITIONWIDGET) {
1496                         Transition *tr = static_cast <Transition *>(selection.at(i));
1497                         if (tr->startPos() - info.startPos > GenTime(5, m_document->fps())) {
1498                             if (tr->startPos() < info.endPos) info.endPos = tr->startPos();
1499                         } else transitionAccepted = false;
1500                     }
1501                 }
1502                 int transitiontrack = getPreviousVideoTrack(info.track);
1503                 if (transitionAccepted) slotAddTransition(item, info, transitiontrack, transition);
1504                 else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1505             }
1506         }
1507 }
1508
1509 void CustomTrackView::slotAddTransition(ClipItem* /*clip*/, ItemInfo transitionInfo, int endTrack, QDomElement transition) {
1510     if (transitionInfo.startPos >= transitionInfo.endPos) {
1511         emit displayMessage(i18n("Invalid transition"), ErrorMessage);
1512         return;
1513     }
1514     AddTransitionCommand* command = new AddTransitionCommand(this, transitionInfo, endTrack, transition, false, true);
1515     m_commandStack->push(command);
1516     m_document->setModified(true);
1517 }
1518
1519 void CustomTrackView::addTransition(ItemInfo transitionInfo, int endTrack, QDomElement params) {
1520     Transition *tr = new Transition(transitionInfo, endTrack, m_document->fps(), params, true);
1521     //kDebug() << "---- ADDING transition " << params.attribute("value");
1522     if (m_document->renderer()->mltAddTransition(tr->transitionTag(), endTrack, m_document->tracksCount() - transitionInfo.track, transitionInfo.startPos, transitionInfo.endPos, tr->toXML())) {
1523         scene()->addItem(tr);
1524         m_document->setModified(true);
1525     } else {
1526         emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1527         delete tr;
1528     }
1529 }
1530
1531 void CustomTrackView::deleteTransition(ItemInfo transitionInfo, int endTrack, QDomElement /*params*/) {
1532     Transition *item = getTransitionItemAt(transitionInfo.startPos, transitionInfo.track);
1533     if (!item) {
1534         emit displayMessage(i18n("Select clip to delete"), ErrorMessage);
1535         return;
1536     }
1537     m_document->renderer()->mltDeleteTransition(item->transitionTag(), endTrack, m_document->tracksCount() - transitionInfo.track, transitionInfo.startPos, transitionInfo.endPos, item->toXML());
1538     if (m_dragItem == item) m_dragItem = NULL;
1539     delete item;
1540     emit transitionItemSelected(NULL);
1541     m_document->setModified(true);
1542 }
1543
1544 void CustomTrackView::slotTransitionUpdated(Transition *tr, QDomElement old) {
1545     kDebug() << "TRANS UPDATE, TRACKS: " << old.attribute("transition_btrack") << ", NEW: " << tr->toXML().attribute("transition_btrack");
1546     EditTransitionCommand *command = new EditTransitionCommand(this, tr->track(), tr->startPos(), old, tr->toXML(), false);
1547     m_commandStack->push(command);
1548     m_document->setModified(true);
1549 }
1550
1551 void CustomTrackView::updateTransition(int track, GenTime pos, QDomElement oldTransition, QDomElement transition, bool updateTransitionWidget) {
1552     Transition *item = getTransitionItemAt(pos, track);
1553     if (!item) {
1554         kWarning() << "Unable to find transition at pos :" << pos.frames(m_document->fps()) << ", ON track: " << track;
1555         return;
1556     }
1557     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);
1558     //kDebug() << "ORIGINAL TRACK: "<< oldTransition.attribute("transition_btrack") << ", NEW TRACK: "<<transition.attribute("transition_btrack");
1559     item->setTransitionParameters(transition);
1560     if (updateTransitionWidget) emit transitionItemSelected(item, true);
1561     m_document->setModified(true);
1562 }
1563
1564 void CustomTrackView::dragMoveEvent(QDragMoveEvent * event) {
1565     event->setDropAction(Qt::IgnoreAction);
1566     const QPointF pos = mapToScene(event->pos());
1567     if (m_selectionGroup && m_clipDrag) {
1568         m_selectionGroup->setPos(pos.x(), pos.y());
1569         event->setDropAction(Qt::MoveAction);
1570         event->acceptProposedAction();
1571     } else {
1572         QGraphicsView::dragMoveEvent(event);
1573     }
1574 }
1575
1576 void CustomTrackView::dragLeaveEvent(QDragLeaveEvent * event) {
1577     if (m_selectionGroup && m_clipDrag) {
1578         QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1579         qDeleteAll(items);
1580         scene()->destroyItemGroup(m_selectionGroup);
1581         m_selectionGroup = NULL;
1582     } else QGraphicsView::dragLeaveEvent(event);
1583 }
1584
1585 void CustomTrackView::dropEvent(QDropEvent * event) {
1586     if (m_selectionGroup && m_clipDrag) {
1587         QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1588         resetSelectionGroup();
1589         m_scene->clearSelection();
1590         bool hasVideoClip = false;
1591         for (int i = 0; i < items.count(); i++) {
1592             ClipItem *item = static_cast <ClipItem *>(items.at(i));
1593             if (!hasVideoClip && (item->clipType() == AV || item->clipType() == VIDEO)) hasVideoClip = true;
1594             AddTimelineClipCommand *command = new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, false);
1595             m_commandStack->push(command);
1596             item->baseClip()->addReference();
1597             m_document->updateClip(item->baseClip()->getId());
1598             ItemInfo info = item->info();
1599
1600             int tracknumber = m_document->tracksCount() - info.track - 1;
1601             bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
1602             if (isLocked) item->setItemLocked(true);
1603
1604             if (item->baseClip()->isTransparent()) {
1605                 // add transparency transition
1606                 int endTrack = getPreviousVideoTrack(info.track);
1607                 Transition *tr = new Transition(info, endTrack, m_document->fps(), MainWindow::transitions.getEffectByTag("composite", "composite"), true);
1608                 if (m_document->renderer()->mltAddTransition(tr->transitionTag(), endTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML())) {
1609                     scene()->addItem(tr);
1610                 } else {
1611                     emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1612                     delete tr;
1613                 }
1614             }
1615             info.track = m_document->tracksCount() - item->track();
1616             m_document->renderer()->mltInsertClip(info, item->xml(), item->baseClip()->producer(item->track()));
1617             item->setSelected(true);
1618         }
1619         m_changeSpeedAction->setEnabled(hasVideoClip);
1620         m_pasteEffectsAction->setEnabled(m_copiedItems.count() == 1);
1621         groupSelectedItems(true);
1622     } else QGraphicsView::dropEvent(event);
1623     setFocus();
1624 }
1625
1626
1627 QStringList CustomTrackView::mimeTypes() const {
1628     QStringList qstrList;
1629     // list of accepted mime types for drop
1630     qstrList.append("text/plain");
1631     qstrList.append("kdenlive/producerslist");
1632     qstrList.append("kdenlive/clip");
1633     return qstrList;
1634 }
1635
1636 Qt::DropActions CustomTrackView::supportedDropActions() const {
1637     // returns what actions are supported when dropping
1638     return Qt::MoveAction;
1639 }
1640
1641 void CustomTrackView::setDuration(int duration) {
1642     int diff = qAbs(duration - sceneRect().width());
1643     if (diff * matrix().m11() > -50) {
1644         if (matrix().m11() < 0.4) setSceneRect(0, 0, (duration + 100 / matrix().m11()), sceneRect().height());
1645         else setSceneRect(0, 0, (duration + 300), sceneRect().height());
1646     }
1647     m_projectDuration = duration;
1648 }
1649
1650 int CustomTrackView::duration() const {
1651     return m_projectDuration;
1652 }
1653
1654 void CustomTrackView::addTrack(TrackInfo type, int ix) {
1655     if (ix == -1) m_document->insertTrack(ix, type);
1656     else {
1657         m_document->insertTrack(m_document->tracksCount() - ix, type);
1658         // insert track in MLT playlist
1659         m_document->renderer()->mltInsertTrack(m_document->tracksCount() - ix, type.type == VIDEOTRACK);
1660
1661         double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
1662         QRectF r(0, startY, sceneRect().width(), sceneRect().height() - startY);
1663         QList<QGraphicsItem *> selection = m_scene->items(r);
1664         resetSelectionGroup();
1665
1666         m_selectionGroup = new AbstractGroupItem(m_document->fps());
1667         scene()->addItem(m_selectionGroup);
1668         for (int i = 0; i < selection.count(); i++) {
1669             if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET)
1670                 m_selectionGroup->addToGroup(selection.at(i));
1671             selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
1672         }
1673         // Move graphic items
1674         m_selectionGroup->translate(0, m_tracksHeight);
1675
1676         // adjust track number
1677         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
1678         for (int i = 0; i < children.count(); i++) {
1679             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
1680             item->updateItem();
1681             ItemInfo clipinfo = item->info();
1682             if (item->type() == AVWIDGET) {
1683                 ClipItem *clip = static_cast <ClipItem *>(item);
1684                 // We add a move clip command so that we get the correct producer for new track number
1685                 if (clip->clipType() == AV || clip->clipType() == AUDIO) {
1686                     m_document->renderer()->mltUpdateClipProducer((int)(m_document->tracksCount() - clipinfo.track), clipinfo.startPos.frames(m_document->fps()), clip->baseClip()->producer(clipinfo.track));
1687                     kDebug() << "// UPDATING CLIP TO TRACK PROD: " << clipinfo.track;
1688                 }
1689             } else if (item->type() == TRANSITIONWIDGET) {
1690                 Transition *tr = static_cast <Transition *>(item);
1691                 int track = tr->transitionEndTrack();
1692                 if (track >= ix) {
1693                     tr->updateTransitionEndTrack(getPreviousVideoTrack(clipinfo.track));
1694                 }
1695             }
1696         }
1697         resetSelectionGroup(false);
1698
1699     }
1700     int maxHeight = m_tracksHeight * m_document->tracksCount();
1701     for (int i = 0; i < m_guides.count(); i++) {
1702         QLineF l = m_guides.at(i)->line();
1703         l.setP2(QPointF(l.x2(), maxHeight));
1704         m_guides.at(i)->setLine(l);
1705     }
1706     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), maxHeight);
1707     setSceneRect(0, 0, sceneRect().width(), maxHeight);
1708     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
1709     viewport()->update();
1710     //setFixedHeight(50 * m_tracksCount);
1711 }
1712
1713 void CustomTrackView::removeTrack(int ix) {
1714     // Delete track in MLT playlist
1715     m_document->renderer()->mltDeleteTrack(m_document->tracksCount() - ix);
1716     m_document->deleteTrack(m_document->tracksCount() - ix - 1);
1717
1718     double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
1719     QRectF r(0, startY, sceneRect().width(), sceneRect().height() - startY);
1720     QList<QGraphicsItem *> selection = m_scene->items(r);
1721
1722     resetSelectionGroup();
1723
1724     m_selectionGroup = new AbstractGroupItem(m_document->fps());
1725     scene()->addItem(m_selectionGroup);
1726     for (int i = 0; i < selection.count(); i++) {
1727         if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET) {
1728             m_selectionGroup->addToGroup(selection.at(i));
1729             selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
1730         }
1731     }
1732     // Move graphic items
1733     qreal ydiff = 0 - (int) m_tracksHeight;
1734     m_selectionGroup->translate(0, ydiff);
1735
1736     // adjust track number
1737     QList<QGraphicsItem *> children = m_selectionGroup->childItems();
1738     //kDebug() << "// FOUND CLIPS TO MOVE: " << children.count();
1739     for (int i = 0; i < children.count(); i++) {
1740         if (children.at(i)->type() == AVWIDGET) {
1741             ClipItem *clip = static_cast <ClipItem *>(children.at(i));
1742             clip->updateItem();
1743             ItemInfo clipinfo = clip->info();
1744             kDebug() << "// CLIP TRK IS: " << clipinfo.track;
1745             // We add a move clip command so that we get the correct producer for new track number
1746             if (clip->clipType() == AV || clip->clipType() == AUDIO)
1747                 m_document->renderer()->mltUpdateClipProducer((int)(m_document->tracksCount() - clipinfo.track), clipinfo.startPos.frames(m_document->fps()), clip->baseClip()->producer(clipinfo.track));
1748         } else if (children.at(i)->type() == TRANSITIONWIDGET) {
1749             Transition *tr = static_cast <Transition *>(children.at(i));
1750             tr->updateItem();
1751             int track = tr->transitionEndTrack();
1752             if (track >= ix) {
1753                 ItemInfo clipinfo = tr->info();
1754                 tr->updateTransitionEndTrack(getPreviousVideoTrack(clipinfo.track));
1755             }
1756         }
1757     }
1758     resetSelectionGroup(false);
1759
1760     int maxHeight = m_tracksHeight * m_document->tracksCount();
1761     for (int i = 0; i < m_guides.count(); i++) {
1762         QLineF l = m_guides.at(i)->line();
1763         l.setP2(QPointF(l.x2(), maxHeight));
1764         m_guides.at(i)->setLine(l);
1765     }
1766     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), maxHeight);
1767     setSceneRect(0, 0, sceneRect().width(), maxHeight);
1768     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
1769     viewport()->update();
1770 }
1771
1772 void CustomTrackView::changeTrack(int ix, TrackInfo type) {
1773     int tracknumber = m_document->tracksCount() - ix;
1774     m_document->setTrackType(tracknumber - 1, type);
1775     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
1776     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
1777     viewport()->update();
1778 }
1779
1780
1781 void CustomTrackView::slotSwitchTrackAudio(int ix) {
1782     /*for (int i = 0; i < m_document->tracksCount(); i++)
1783         kDebug() << "TRK " << i << " STATE: " << m_document->trackInfoAt(i).isMute << m_document->trackInfoAt(i).isBlind;*/
1784     int tracknumber = m_document->tracksCount() - ix;
1785     m_document->switchTrackAudio(tracknumber - 1, !m_document->trackInfoAt(tracknumber - 1).isMute);
1786     kDebug() << "NEXT TRK STATE: " << m_document->trackInfoAt(tracknumber - 1).isMute << m_document->trackInfoAt(tracknumber - 1).isBlind;
1787     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
1788     m_document->setModified(true);
1789 }
1790
1791 void CustomTrackView::slotSwitchTrackLock(int ix) {
1792     int tracknumber = m_document->tracksCount() - ix - 1;
1793     LockTrackCommand *command = new LockTrackCommand(this, ix, !m_document->trackInfoAt(tracknumber).isLocked, true);
1794     m_commandStack->push(command);
1795 }
1796
1797
1798 void CustomTrackView::lockTrack(int ix, bool lock) {
1799     int tracknumber = m_document->tracksCount() - ix - 1;
1800     m_document->switchTrackLock(tracknumber, lock);
1801     emit doTrackLock(ix, lock);
1802     QList<QGraphicsItem *> selection = items(0, ix * m_tracksHeight + m_tracksHeight / 2, mapFromScene(sceneRect().width(), 0).x(), m_tracksHeight / 2 - 2);
1803
1804     for (int i = 0; i < selection.count(); i++) {
1805         if (selection.at(i)->type() != AVWIDGET && selection.at(i)->type() != TRANSITIONWIDGET) continue;
1806         if (selection.at(i)->isSelected()) {
1807             if (selection.at(i)->type() == AVWIDGET) emit clipItemSelected(NULL);
1808             else emit transitionItemSelected(NULL);
1809         }
1810         static_cast <AbstractClipItem *>(selection.at(i))->setItemLocked(lock);
1811     }
1812     kDebug() << "NEXT TRK STATE: " << m_document->trackInfoAt(tracknumber).isLocked;
1813     viewport()->update();
1814     m_document->setModified(true);
1815 }
1816
1817 void CustomTrackView::slotSwitchTrackVideo(int ix) {
1818     int tracknumber = m_document->tracksCount() - ix;
1819     m_document->switchTrackVideo(tracknumber - 1, !m_document->trackInfoAt(tracknumber - 1).isBlind);
1820     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
1821     m_document->setModified(true);
1822 }
1823
1824 void CustomTrackView::slotRemoveSpace() {
1825     GenTime pos;
1826     int track = 0;
1827     if (m_menuPosition.isNull()) {
1828         pos = GenTime(cursorPos(), m_document->fps());
1829         bool ok;
1830         track = QInputDialog::getInteger(this, i18n("Remove Space"), i18n("Track"), 0, 0, m_document->tracksCount() - 1, 1, &ok);
1831         if (!ok) return;
1832     } else {
1833         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
1834         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight);
1835     }
1836     ClipItem *item = getClipItemAt(pos, track);
1837     if (item) {
1838         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);
1839         return;
1840     }
1841     int length = m_document->renderer()->mltGetSpaceLength(pos, m_document->tracksCount() - track, true);
1842     //kDebug() << "// GOT LENGT; " << length;
1843     if (length <= 0) {
1844         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);
1845         return;
1846     }
1847
1848     QRectF r(pos.frames(m_document->fps()), track * m_tracksHeight + m_tracksHeight / 2, sceneRect().width() - pos.frames(m_document->fps()), m_tracksHeight / 2 - 1);
1849     QList<QGraphicsItem *> items = m_scene->items(r);
1850
1851     QList<ItemInfo> clipsToMove = QList<ItemInfo> ();
1852     QList<ItemInfo> transitionsToMove = QList<ItemInfo> ();
1853
1854     for (int i = 0; i < items.count(); i++) {
1855         if (items.at(i)->type() == AVWIDGET || items.at(i)->type() == TRANSITIONWIDGET) {
1856             AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
1857             ItemInfo info = item->info();
1858             if (item->type() == AVWIDGET) {
1859                 clipsToMove.append(info);
1860             } else if (item->type() == TRANSITIONWIDGET) {
1861                 transitionsToMove.append(info);
1862             }
1863         }
1864     }
1865
1866     InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, GenTime(-length, m_document->fps()), true);
1867     m_commandStack->push(command);
1868 }
1869
1870 void CustomTrackView::slotInsertSpace() {
1871     GenTime pos;
1872     int track = 0;
1873     if (m_menuPosition.isNull()) {
1874         pos = GenTime(cursorPos(), m_document->fps());
1875     } else {
1876         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
1877         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight) + 1;
1878     }
1879     SpacerDialog d(GenTime(65, m_document->fps()), m_document->timecode(), track, m_document->tracksCount(), this);
1880     if (d.exec() != QDialog::Accepted) return;
1881     GenTime spaceDuration = d.selectedDuration();
1882     track = d.selectedTrack();
1883     ClipItem *item = getClipItemAt(pos, track);
1884     if (item) pos = item->startPos();
1885
1886     int minh = 0;
1887     int maxh = sceneRect().height();
1888     if (track != -1) {
1889         minh = track * m_tracksHeight + m_tracksHeight / 2;
1890         maxh = m_tracksHeight / 2 - 1;
1891     }
1892
1893     QRectF r(pos.frames(m_document->fps()), minh, sceneRect().width() - pos.frames(m_document->fps()), maxh);
1894     QList<QGraphicsItem *> items = m_scene->items(r);
1895
1896     QList<ItemInfo> clipsToMove = QList<ItemInfo> ();
1897     QList<ItemInfo> transitionsToMove = QList<ItemInfo> ();
1898
1899     for (int i = 0; i < items.count(); i++) {
1900         if (items.at(i)->type() == AVWIDGET || items.at(i)->type() == TRANSITIONWIDGET) {
1901             AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
1902             ItemInfo info = item->info();
1903             if (item->type() == AVWIDGET) {
1904                 clipsToMove.append(info);
1905             } else if (item->type() == TRANSITIONWIDGET) {
1906                 transitionsToMove.append(info);
1907             }
1908         }
1909     }
1910
1911     InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, spaceDuration, true);
1912     m_commandStack->push(command);
1913 }
1914
1915 void CustomTrackView::insertSpace(QList<ItemInfo> clipsToMove, QList<ItemInfo> transToMove, int track, const GenTime duration, const GenTime offset) {
1916     int diff = duration.frames(m_document->fps());
1917     resetSelectionGroup();
1918     m_selectionGroup = new AbstractGroupItem(m_document->fps());
1919     scene()->addItem(m_selectionGroup);
1920     ClipItem *clip;
1921     Transition *transition;
1922
1923     kDebug() << "/// STARTING SPACE INSERT";
1924
1925
1926     // Create lists with start pos for each track
1927     QMap <int, int> trackClipStartList;
1928     QMap <int, int> trackTransitionStartList;
1929
1930     for (int i = 1; i < m_document->tracksCount() + 1; i++) {
1931         trackClipStartList[i] = -1;
1932         trackTransitionStartList[i] = -1;
1933     }
1934
1935     if (!clipsToMove.isEmpty()) for (int i = 0; i < clipsToMove.count(); i++) {
1936             kDebug() << "/// FETCHING CLIP: " << i;
1937             clip = getClipItemAtStart(clipsToMove.at(i).startPos + offset, clipsToMove.at(i).track);
1938             if (clip) {
1939                 m_selectionGroup->addToGroup(clip);
1940                 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))
1941                     trackClipStartList[m_document->tracksCount() - clipsToMove.at(i).track] = clipsToMove.at(i).startPos.frames(m_document->fps());
1942                 clip->setFlags(QGraphicsItem::ItemIsSelectable);
1943             } 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);
1944         }
1945     if (!transToMove.isEmpty()) for (int i = 0; i < transToMove.count(); i++) {
1946             kDebug() << "/// FETCHING TRANS: " << i;
1947             transition = getTransitionItemAtStart(transToMove.at(i).startPos + offset, transToMove.at(i).track);
1948             if (transition) {
1949                 m_selectionGroup->addToGroup(transition);
1950                 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))
1951                     trackTransitionStartList[m_document->tracksCount() - transToMove.at(i).track] = transToMove.at(i).startPos.frames(m_document->fps());
1952                 transition->setFlags(QGraphicsItem::ItemIsSelectable);
1953             } 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);
1954         }
1955     kDebug() << "/// STARTING SPACE DONE";
1956     m_selectionGroup->translate(diff, 0);
1957     resetSelectionGroup(false);
1958     kDebug() << "/// STARTING SPACE DONE2";
1959     if (track != -1) track = m_document->tracksCount() - track;
1960     m_document->renderer()->mltInsertSpace(trackClipStartList, trackTransitionStartList, track, duration, offset);
1961 }
1962
1963 void CustomTrackView::deleteClip(const QString &clipId) {
1964     QList<QGraphicsItem *> itemList = items();
1965     QUndoCommand *deleteCommand = new QUndoCommand();
1966     deleteCommand->setText(i18n("Delete timeline clips"));
1967     int count = 0;
1968     for (int i = 0; i < itemList.count(); i++) {
1969         if (itemList.at(i)->type() == AVWIDGET) {
1970             ClipItem *item = (ClipItem *)itemList.at(i);
1971             if (item->clipProducer() == clipId) {
1972                 count++;
1973                 new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true, deleteCommand);
1974                 //delete item;
1975             }
1976         }
1977     }
1978
1979 }
1980
1981 void CustomTrackView::setCursorPos(int pos, bool seek) {
1982     emit cursorMoved((int)(m_cursorPos), (int)(pos));
1983     m_cursorPos = pos;
1984     m_cursorLine->setPos(pos, 0);
1985     if (seek) m_document->renderer()->seek(GenTime(pos, m_document->fps()));
1986     else if (m_autoScroll) checkScrolling();
1987 }
1988
1989 void CustomTrackView::updateCursorPos() {
1990     m_cursorLine->setPos(m_cursorPos, 0);
1991 }
1992
1993 int CustomTrackView::cursorPos() {
1994     return (int)(m_cursorPos);
1995 }
1996
1997 void CustomTrackView::moveCursorPos(int delta) {
1998     if (m_cursorPos + delta < 0) delta = 0 - m_cursorPos;
1999     emit cursorMoved((int)(m_cursorPos), (int)((m_cursorPos + delta)));
2000     m_cursorPos += delta;
2001     m_cursorLine->setPos(m_cursorPos, 0);
2002     m_document->renderer()->seek(GenTime(m_cursorPos, m_document->fps()));
2003 }
2004
2005 void CustomTrackView::initCursorPos(int pos) {
2006     emit cursorMoved((int)(m_cursorPos), (int)(pos));
2007     m_cursorPos = pos;
2008     m_cursorLine->setPos(pos, 0);
2009     checkScrolling();
2010 }
2011
2012 void CustomTrackView::checkScrolling() {
2013     int vert = verticalScrollBar()->value();
2014     int hor = cursorPos();
2015     ensureVisible(hor, vert + 10, 2, 2, 50, 0);
2016 }
2017
2018 void CustomTrackView::mouseReleaseEvent(QMouseEvent * event) {
2019     if (m_moveOpMode == SEEK) m_moveOpMode = NONE;
2020     QGraphicsView::mouseReleaseEvent(event);
2021     if (m_scrollTimer.isActive()) m_scrollTimer.stop();
2022     if (event->button() == Qt::MidButton) {
2023         return;
2024     }
2025     setDragMode(QGraphicsView::NoDrag);
2026     if (m_operationMode == MOVEGUIDE) {
2027         setCursor(Qt::ArrowCursor);
2028         m_operationMode = NONE;
2029         m_dragGuide->setFlag(QGraphicsItem::ItemIsMovable, false);
2030         EditGuideCommand *command = new EditGuideCommand(this, m_dragGuide->position(), m_dragGuide->label(), GenTime(m_dragGuide->pos().x(), m_document->fps()), m_dragGuide->label(), false);
2031         m_commandStack->push(command);
2032         m_dragGuide->updateGuide(GenTime(m_dragGuide->pos().x(), m_document->fps()));
2033         m_dragGuide = NULL;
2034         m_dragItem = NULL;
2035         return;
2036     } else if (m_operationMode == SPACER) {
2037         int track = (int)(mapToScene(m_clickEvent).y() / m_tracksHeight);
2038         if (m_selectionGroup->sceneBoundingRect().height() > m_tracksHeight) {
2039             // We are moving all tracks
2040             track = -1;
2041         }
2042         GenTime timeOffset = GenTime(m_selectionGroup->scenePos().x(), m_document->fps()) - m_selectionGroupInfo.startPos;
2043         if (timeOffset != GenTime()) {
2044             QList<QGraphicsItem *> items = m_selectionGroup->childItems();
2045
2046             QList<ItemInfo> clipsToMove = QList<ItemInfo> ();
2047             QList<ItemInfo> transitionsToMove = QList<ItemInfo> ();
2048
2049             // Create lists with start pos for each track
2050             QMap <int, int> trackClipStartList;
2051             QMap <int, int> trackTransitionStartList;
2052
2053             for (int i = 1; i < m_document->tracksCount() + 1; i++) {
2054                 trackClipStartList[i] = -1;
2055                 trackTransitionStartList[i] = -1;
2056             }
2057
2058             for (int i = 0; i < items.count(); i++) {
2059                 AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2060                 ItemInfo info = item->info();
2061                 if (item->type() == AVWIDGET) {
2062                     clipsToMove.append(info);
2063                     if (trackClipStartList.value(m_document->tracksCount() - info.track) == -1 || info.startPos.frames(m_document->fps()) < trackClipStartList.value(m_document->tracksCount() - info.track))
2064                         trackClipStartList[m_document->tracksCount() - info.track] = info.startPos.frames(m_document->fps());
2065                 } else if (item->type() == TRANSITIONWIDGET) {
2066                     transitionsToMove.append(info);
2067                     if (trackClipStartList.value(m_document->tracksCount() - info.track) == -1 || info.startPos.frames(m_document->fps()) < trackTransitionStartList.value(m_document->tracksCount() - info.track))
2068                         trackTransitionStartList[m_document->tracksCount() - info.track] = info.startPos.frames(m_document->fps());
2069                 }
2070             }
2071
2072             InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, timeOffset, false);
2073             m_commandStack->push(command);
2074             if (track != -1) track = m_document->tracksCount() - track;
2075             m_document->renderer()->mltInsertSpace(trackClipStartList, trackTransitionStartList, track, timeOffset, GenTime());
2076         }
2077         resetSelectionGroup(false);
2078         m_operationMode = NONE;
2079     } else if (m_operationMode == RUBBERSELECTION) {
2080         kDebug() << "// END RUBBER SELECT";
2081         resetSelectionGroup();
2082         groupSelectedItems();
2083         m_operationMode = NONE;
2084     }
2085
2086     if (m_dragItem == NULL && m_selectionGroup == NULL) {
2087         emit transitionItemSelected(NULL);
2088         return;
2089     }
2090     ItemInfo info;
2091     if (m_dragItem) info = m_dragItem->info();
2092
2093     if (m_operationMode == MOVE) {
2094         setCursor(Qt::OpenHandCursor);
2095
2096         if (m_dragItem->parentItem() == 0) {
2097             // we are moving one clip, easy
2098             if (m_dragItem->type() == AVWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
2099                 ClipItem *item = static_cast <ClipItem *>(m_dragItem);
2100                 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));
2101                 if (success) {
2102                     int tracknumber = m_document->tracksCount() - item->track() - 1;
2103                     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2104                     if (isLocked) item->setItemLocked(true);
2105
2106                     QUndoCommand *moveCommand = new QUndoCommand();
2107                     moveCommand->setText(i18n("Move clip"));
2108                     new MoveClipCommand(this, m_dragItemInfo, info, false, moveCommand);
2109                     // Also move automatic transitions (on lower track)
2110                     Transition *tr = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track);
2111                     if (tr && tr->isAutomatic()) {
2112                         ItemInfo trInfo = tr->info();
2113                         ItemInfo newTrInfo = trInfo;
2114                         newTrInfo.track = info.track;
2115                         newTrInfo.startPos = m_dragItem->startPos();
2116                         if (m_dragItemInfo.track == info.track && !item->baseClip()->isTransparent() && getClipItemAtEnd(newTrInfo.endPos, m_document->tracksCount() - tr->transitionEndTrack())) {
2117                             // transition end should stay the same
2118                         } else {
2119                             // transition end should be adjusted to clip
2120                             newTrInfo.endPos = newTrInfo.endPos + (newTrInfo.startPos - trInfo.startPos);
2121                         }
2122                         if (newTrInfo.startPos < newTrInfo.endPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2123                     }
2124                     if (tr == NULL || tr->endPos() < m_dragItemInfo.endPos) {
2125                         // Check if there is a transition at clip end
2126                         tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track);
2127                         if (tr && tr->isAutomatic()) {
2128                             ItemInfo trInfo = tr->info();
2129                             ItemInfo newTrInfo = trInfo;
2130                             newTrInfo.track = info.track;
2131                             newTrInfo.endPos = m_dragItem->endPos();
2132                             if (m_dragItemInfo.track == info.track && !item->baseClip()->isTransparent() && getClipItemAtStart(trInfo.startPos, m_document->tracksCount() - tr->transitionEndTrack())) {
2133                                 // transition start should stay the same
2134                             } else {
2135                                 // transition start should be moved
2136                                 newTrInfo.startPos = newTrInfo.startPos + (newTrInfo.endPos - trInfo.endPos);
2137                             }
2138                             if (newTrInfo.startPos < newTrInfo.endPos)
2139                                 new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2140                         }
2141                     }
2142                     // Also move automatic transitions (on upper track)
2143                     tr = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2144                     if (m_dragItemInfo.track == info.track && tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
2145                         ItemInfo trInfo = tr->info();
2146                         ItemInfo newTrInfo = trInfo;
2147                         newTrInfo.startPos = m_dragItem->startPos();
2148                         ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2149                         if (!upperClip || !upperClip->baseClip()->isTransparent()) {
2150                             if (!getClipItemAtEnd(newTrInfo.endPos, tr->track())) {
2151                                 // transition end should be adjusted to clip on upper track
2152                                 newTrInfo.endPos = newTrInfo.endPos + (newTrInfo.startPos - trInfo.startPos);
2153                             }
2154                             if (newTrInfo.startPos < newTrInfo.endPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2155                         }
2156                     }
2157                     if (m_dragItemInfo.track == info.track && (tr == NULL || tr->endPos() < m_dragItemInfo.endPos)) {
2158                         // Check if there is a transition at clip end
2159                         tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
2160                         if (tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
2161                             ItemInfo trInfo = tr->info();
2162                             ItemInfo newTrInfo = trInfo;
2163                             newTrInfo.endPos = m_dragItem->endPos();
2164                             ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2165                             if (!upperClip || !upperClip->baseClip()->isTransparent()) {
2166                                 if (!getClipItemAtStart(trInfo.startPos, tr->track())) {
2167                                     // transition start should be moved
2168                                     newTrInfo.startPos = newTrInfo.startPos + (newTrInfo.endPos - trInfo.endPos);
2169                                 }
2170                                 if (newTrInfo.startPos < newTrInfo.endPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2171                             }
2172                         }
2173                     }
2174                     m_commandStack->push(moveCommand);
2175                 } else {
2176                     // undo last move and emit error message
2177                     MoveClipCommand *command = new MoveClipCommand(this, info, m_dragItemInfo, true);
2178                     m_commandStack->push(command);
2179                     emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(m_dragItemInfo.startPos.frames(m_document->fps()))), ErrorMessage);
2180                 }
2181                 m_document->setModified(true);
2182             }
2183             if (m_dragItem->type() == TRANSITIONWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
2184                 Transition *transition = static_cast <Transition *>(m_dragItem);
2185                 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)) {
2186                     // Moving transition failed, revert to previous position
2187                     emit displayMessage(i18n("Cannot move transition"), ErrorMessage);
2188                     transition->setPos((int) m_dragItemInfo.startPos.frames(m_document->fps()), (m_dragItemInfo.track) * m_tracksHeight + 1);
2189                 } else {
2190                     MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
2191                     m_commandStack->push(command);
2192                     transition->updateTransitionEndTrack(getPreviousVideoTrack(m_dragItem->track()));
2193                 }
2194             }
2195         } else {
2196             // Moving several clips. We need to delete them and readd them to new position,
2197             // or they might overlap each other during the move
2198             QGraphicsItemGroup *group = static_cast <QGraphicsItemGroup *>(m_dragItem->parentItem());
2199             QList<QGraphicsItem *> items = group->childItems();
2200
2201             QList<ItemInfo> clipsToMove = QList<ItemInfo> ();
2202             QList<ItemInfo> transitionsToMove = QList<ItemInfo> ();
2203
2204             GenTime timeOffset = GenTime(m_dragItem->scenePos().x(), m_document->fps()) - m_dragItemInfo.startPos;
2205             const int trackOffset = m_dragItem->track() - m_dragItemInfo.track;
2206             kDebug() << "// MOVED SEVERAL CLIPS" << timeOffset.frames(25);
2207             if (timeOffset != GenTime() || trackOffset != 0) {
2208                 // remove items in MLT playlist
2209
2210                 // Expand groups
2211                 int max = items.count();
2212                 for (int i = 0; i < max; i++) {
2213                     if (items.at(i)->type() == GROUPWIDGET) {
2214                         items += items.at(i)->childItems();
2215                     }
2216                 }
2217
2218                 for (int i = 0; i < items.count(); i++) {
2219                     if (items.at(i)->type() != AVWIDGET && items.at(i)->type() != TRANSITIONWIDGET) continue;
2220                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2221                     ItemInfo info = item->info();
2222                     if (item->type() == AVWIDGET) {
2223                         if (m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
2224                             // error, clip cannot be removed from playlist
2225                             emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
2226                         } else {
2227                             clipsToMove.append(info);
2228                         }
2229                     } else {
2230                         transitionsToMove.append(info);
2231                         Transition *tr = static_cast <Transition*>(item);
2232                         m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2233                     }
2234                 }
2235
2236                 for (int i = 0; i < items.count(); i++) {
2237                     // re-add items in correct place
2238                     if (items.at(i)->type() != AVWIDGET && items.at(i)->type() != TRANSITIONWIDGET) continue;
2239                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2240                     item->updateItem();
2241                     ItemInfo info = item->info();
2242                     int tracknumber = m_document->tracksCount() - info.track - 1;
2243                     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2244                     if (isLocked) {
2245                         group->removeFromGroup(item);
2246                         item->setItemLocked(true);
2247                     }
2248
2249                     if (item->type() == AVWIDGET) {
2250                         ClipItem *clip = static_cast <ClipItem*>(item);
2251                         info.track = m_document->tracksCount() - info.track;
2252                         m_document->renderer()->mltInsertClip(info, clip->xml(), clip->baseClip()->producer(info.track));
2253                         for (int i = 0; i < clip->effectsCount(); i++) {
2254                             m_document->renderer()->mltAddEffect(info.track, info.startPos, clip->getEffectArgs(clip->effectAt(i)), false);
2255                         }
2256                     } else {
2257                         Transition *tr = static_cast <Transition*>(item);
2258                         int newTrack = tr->transitionEndTrack();
2259                         if (!tr->forcedTrack()) {
2260                             newTrack = getPreviousVideoTrack(info.track);
2261                         }
2262                         tr->updateTransitionEndTrack(newTrack);
2263                         m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2264                     }
2265                 }
2266
2267                 MoveGroupCommand *move = new MoveGroupCommand(this, clipsToMove, transitionsToMove, timeOffset, trackOffset, false);
2268                 m_commandStack->push(move);
2269
2270                 //QPointF top = group->sceneBoundingRect().topLeft();
2271                 //QPointF oldpos = m_selectionGroup->scenePos();
2272                 //kDebug()<<"SELECTION GRP POS: "<<m_selectionGroup->scenePos()<<", TOP: "<<top;
2273                 //group->setPos(top);
2274                 //TODO: get rid of the 3 lines below
2275                 if (m_selectionGroup) {
2276                     m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
2277                     m_selectionGroupInfo.track = m_selectionGroup->track();
2278                 }
2279                 m_document->setModified(true);
2280             }
2281         }
2282
2283     } else if (m_operationMode == RESIZESTART && m_dragItem->startPos() != m_dragItemInfo.startPos) {
2284         // resize start
2285         if (m_dragItem->type() == AVWIDGET) {
2286             ItemInfo resizeinfo = m_dragItemInfo;
2287             resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
2288             bool success = m_document->renderer()->mltResizeClipStart(resizeinfo, m_dragItem->startPos() - m_dragItemInfo.startPos);
2289             if (success) {
2290                 QUndoCommand *resizeCommand = new QUndoCommand();
2291                 resizeCommand->setText(i18n("Resize clip"));
2292
2293                 // Check if there is an automatic transition on that clip (lower track)
2294                 Transition *transition = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track);
2295                 if (transition && transition->isAutomatic()) {
2296                     ItemInfo trInfo = transition->info();
2297                     ItemInfo newTrInfo = trInfo;
2298                     newTrInfo.startPos = m_dragItem->startPos();
2299                     if (newTrInfo.startPos < newTrInfo.endPos)
2300                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2301                 }
2302                 // Check if there is an automatic transition on that clip (upper track)
2303                 transition = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2304                 if (transition && transition->isAutomatic() && (m_document->tracksCount() - transition->transitionEndTrack()) == m_dragItemInfo.track) {
2305                     ItemInfo trInfo = transition->info();
2306                     ItemInfo newTrInfo = trInfo;
2307                     newTrInfo.startPos = m_dragItem->startPos();
2308                     ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2309                     if ((!upperClip || !upperClip->baseClip()->isTransparent()) && newTrInfo.startPos < newTrInfo.endPos) {
2310                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2311                     }
2312                 }
2313                 updateClipFade(static_cast <ClipItem *>(m_dragItem));
2314                 new ResizeClipCommand(this, m_dragItemInfo, info, false, resizeCommand);
2315                 m_commandStack->push(resizeCommand);
2316             } else {
2317                 m_dragItem->resizeStart((int) m_dragItemInfo.startPos.frames(m_document->fps()));
2318                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2319             }
2320         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
2321             Transition *transition = static_cast <Transition *>(m_dragItem);
2322             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)) {
2323                 // Cannot resize transition
2324                 transition->resizeStart((int) m_dragItemInfo.startPos.frames(m_document->fps()));
2325                 emit displayMessage(i18n("Cannot resize transition"), ErrorMessage);
2326             } else {
2327                 MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
2328                 m_commandStack->push(command);
2329             }
2330
2331         }
2332
2333         //m_document->renderer()->doRefresh();
2334     } else if (m_operationMode == RESIZEEND && m_dragItem->endPos() != m_dragItemInfo.endPos) {
2335         // resize end
2336         if (m_dragItem->type() == AVWIDGET) {
2337             ItemInfo resizeinfo = info;
2338             resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
2339             bool success = m_document->renderer()->mltResizeClipEnd(resizeinfo, resizeinfo.endPos - resizeinfo.startPos);
2340             if (success) {
2341                 QUndoCommand *resizeCommand = new QUndoCommand();
2342                 resizeCommand->setText(i18n("Resize clip"));
2343
2344                 // Check if there is an automatic transition on that clip (lower track)
2345                 Transition *tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track);
2346                 if (tr && tr->isAutomatic()) {
2347                     ItemInfo trInfo = tr->info();
2348                     ItemInfo newTrInfo = trInfo;
2349                     newTrInfo.endPos = m_dragItem->endPos();
2350                     if (newTrInfo.endPos > newTrInfo.startPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2351                 }
2352
2353                 // Check if there is an automatic transition on that clip (upper track)
2354                 tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
2355                 if (tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
2356                     ItemInfo trInfo = tr->info();
2357                     ItemInfo newTrInfo = trInfo;
2358                     newTrInfo.endPos = m_dragItem->endPos();
2359                     ClipItem * upperClip = getClipItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
2360                     if ((!upperClip || !upperClip->baseClip()->isTransparent()) && newTrInfo.endPos > newTrInfo.startPos) {
2361                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2362                     }
2363                 }
2364
2365                 new ResizeClipCommand(this, m_dragItemInfo, info, false, resizeCommand);
2366                 m_commandStack->push(resizeCommand);
2367                 updateClipFade(static_cast <ClipItem *>(m_dragItem), true);
2368             } else {
2369                 m_dragItem->resizeEnd((int) m_dragItemInfo.endPos.frames(m_document->fps()));
2370                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2371             }
2372         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
2373             Transition *transition = static_cast <Transition *>(m_dragItem);
2374             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)) {
2375                 // Cannot resize transition
2376                 transition->resizeEnd((int) m_dragItemInfo.endPos.frames(m_document->fps()));
2377                 emit displayMessage(i18n("Cannot resize transition"), ErrorMessage);
2378             } else {
2379                 MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
2380                 m_commandStack->push(command);
2381             }
2382         }
2383         //m_document->renderer()->doRefresh();
2384     } else if (m_operationMode == FADEIN) {
2385         // resize fade in effect
2386         ClipItem * item = (ClipItem *) m_dragItem;
2387         int ix = item->hasEffect("volume", "fadein");
2388         if (ix != -1) {
2389             QDomElement oldeffect = item->effectAt(ix);
2390             int start = item->cropStart().frames(m_document->fps());
2391             int end = item->fadeIn();
2392             if (end == 0) {
2393                 slotDeleteEffect(item, oldeffect);
2394             } else {
2395                 end += start;
2396                 QDomElement effect = oldeffect.cloneNode().toElement();
2397                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2398                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2399                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2400                 emit clipItemSelected(item, ix);
2401             }
2402         } else if (item->fadeIn() != 0 && item->hasEffect("", "fade_from_black") == -1) {
2403             QDomElement effect = MainWindow::audioEffects.getEffectByTag("volume", "fadein").cloneNode().toElement();
2404             EffectsList::setParameter(effect, "out", QString::number(item->fadeIn()));
2405             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
2406         }
2407         ix = item->hasEffect("volume", "fade_from_black");
2408         if (ix != -1) {
2409             QDomElement oldeffect = item->effectAt(ix);
2410             int start = item->cropStart().frames(m_document->fps());
2411             int end = item->fadeIn();
2412             if (end == 0) {
2413                 slotDeleteEffect(item, oldeffect);
2414             } else {
2415                 end += start;
2416                 QDomElement effect = oldeffect.cloneNode().toElement();
2417                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2418                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2419                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2420                 emit clipItemSelected(item, ix);
2421             }
2422         }
2423     } else if (m_operationMode == FADEOUT) {
2424         // resize fade in effect
2425         ClipItem * item = (ClipItem *) m_dragItem;
2426         int ix = item->hasEffect("volume", "fadeout");
2427         if (ix != -1) {
2428             QDomElement oldeffect = item->effectAt(ix);
2429             int end = (item->duration() + item->cropStart()).frames(m_document->fps());
2430             int start = item->fadeOut();
2431             if (start == 0) {
2432                 slotDeleteEffect(item, oldeffect);
2433             } else {
2434                 start = end - start;
2435                 QDomElement effect = oldeffect.cloneNode().toElement();
2436                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2437                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2438                 // kDebug()<<"EDIT FADE OUT : "<<start<<"x"<<end;
2439                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2440                 emit clipItemSelected(item, ix);
2441             }
2442         } else if (item->fadeOut() != 0 && item->hasEffect("", "fade_to_black") == -1) {
2443             QDomElement effect = MainWindow::audioEffects.getEffectByTag("volume", "fadeout").cloneNode().toElement();
2444             EffectsList::setParameter(effect, "in", QString::number(item->fadeOut()));
2445             EffectsList::setParameter(effect, "out", QString::number(0));
2446             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
2447         }
2448         ix = item->hasEffect("brightness", "fade_to_black");
2449         if (ix != -1) {
2450             QDomElement oldeffect = item->effectAt(ix);
2451             int end = (item->duration() + item->cropStart()).frames(m_document->fps());
2452             int start = item->fadeOut();
2453             if (start == 0) {
2454                 slotDeleteEffect(item, oldeffect);
2455             } else {
2456                 start = end - start;
2457                 QDomElement effect = oldeffect.cloneNode().toElement();
2458                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2459                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2460                 // kDebug()<<"EDIT FADE OUT : "<<start<<"x"<<end;
2461                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2462                 emit clipItemSelected(item, ix);
2463             }
2464         }
2465     } else if (m_operationMode == KEYFRAME) {
2466         // update the MLT effect
2467         ClipItem * item = (ClipItem *) m_dragItem;
2468         QString previous = item->keyframes(item->selectedEffectIndex());
2469         item->updateKeyframeEffect();
2470         QString next = item->keyframes(item->selectedEffectIndex());
2471         EditKeyFrameCommand *command = new EditKeyFrameCommand(this, item->track(), item->startPos(), item->selectedEffectIndex(), previous, next, false);
2472         m_commandStack->push(command);
2473         updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
2474     }
2475
2476     emit transitionItemSelected((m_dragItem && m_dragItem->type() == TRANSITIONWIDGET && m_dragItem->isSelected()) ? static_cast <Transition *>(m_dragItem) : NULL);
2477     if (m_operationMode != NONE && m_operationMode != MOVE) m_document->setModified(true);
2478     m_operationMode = NONE;
2479 }
2480
2481 void CustomTrackView::deleteClip(ItemInfo info) {
2482     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
2483
2484     if (!item || m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
2485         emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
2486         return;
2487     }
2488     if (item->isSelected()) emit clipItemSelected(NULL);
2489     item->baseClip()->removeReference();
2490     m_document->updateClip(item->baseClip()->getId());
2491
2492     if (item->baseClip()->isTransparent()) {
2493         // also remove automatic transition
2494         Transition *tr = getTransitionItemAt(info.startPos, info.track);
2495         if (tr && tr->isAutomatic()) {
2496             m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2497             scene()->removeItem(tr);
2498             delete tr;
2499         }
2500     }
2501     scene()->removeItem(item);
2502     if (m_dragItem == item) m_dragItem = NULL;
2503     delete item;
2504     m_document->renderer()->doRefresh();
2505 }
2506
2507 void CustomTrackView::deleteSelectedClips() {
2508     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2509     if (itemList.count() == 0) {
2510         emit displayMessage(i18n("Select clip to delete"), ErrorMessage);
2511         return;
2512     }
2513     QUndoCommand *deleteSelected = new QUndoCommand();
2514     deleteSelected->setText(i18n("Delete selected items"));
2515     bool resetGroup = false;
2516     for (int i = 0; i < itemList.count(); i++) {
2517         if (itemList.at(i)->type() == AVWIDGET) {
2518             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2519             if (item->parentItem()) resetGroup = true;
2520             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true, deleteSelected);
2521         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
2522             Transition *item = static_cast <Transition *>(itemList.at(i));
2523             if (item->parentItem()) resetGroup = true;
2524             ItemInfo info;
2525             info.startPos = item->startPos();
2526             info.endPos = item->endPos();
2527             info.track = item->track();
2528             new AddTransitionCommand(this, info, item->transitionEndTrack(), item->toXML(), true, true, deleteSelected);
2529         }
2530     }
2531     m_commandStack->push(deleteSelected);
2532     if (resetGroup) resetSelectionGroup();
2533 }
2534
2535 void CustomTrackView::changeClipSpeed() {
2536     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2537     if (itemList.count() == 0) {
2538         emit displayMessage(i18n("Select clip to change speed"), ErrorMessage);
2539         return;
2540     }
2541     QUndoCommand *changeSelected = new QUndoCommand();
2542     changeSelected->setText("Edit clip speed");
2543     int count = 0;
2544     int percent = -1;
2545     bool ok;
2546     for (int i = 0; i < itemList.count(); i++) {
2547         if (itemList.at(i)->type() == AVWIDGET) {
2548             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2549             ItemInfo info = item->info();
2550             if (percent == -1) percent = QInputDialog::getInteger(this, i18n("Edit Clip Speed"), i18n("New speed (percents)"), item->speed() * 100, 1, 10000, 1, &ok);
2551             if (!ok) break;
2552             double speed = (double) percent / 100.0;
2553             if (item->speed() != speed && (item->clipType() == VIDEO || item->clipType() == AV)) {
2554                 count++;
2555                 new ChangeSpeedCommand(this, info, item->speed(), speed, item->clipProducer(), true, changeSelected);
2556             }
2557         }
2558     }
2559     if (count > 0) m_commandStack->push(changeSelected);
2560     else delete changeSelected;
2561 }
2562
2563 void CustomTrackView::doChangeClipSpeed(ItemInfo info, const double speed, const double oldspeed, const QString &id) {
2564     DocClipBase *baseclip = m_document->clipManager()->getClipById(id);
2565     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
2566     if (!item) {
2567         kDebug() << "ERROR: Cannot find clip for speed change";
2568         emit displayMessage(i18n("Cannot find clip for speed change"), ErrorMessage);
2569         return;
2570     }
2571     info.track = m_document->tracksCount() - item->track();
2572     int endPos = m_document->renderer()->mltChangeClipSpeed(info, speed, oldspeed, baseclip->producer());
2573     if (endPos >= 0) {
2574         item->setSpeed(speed);
2575         item->updateRectGeometry();
2576         if (item->cropDuration().frames(m_document->fps()) > endPos)
2577             item->AbstractClipItem::resizeEnd(info.startPos.frames(m_document->fps()) + endPos, speed);
2578         m_document->setModified(true);
2579     } else emit displayMessage(i18n("Invalid clip"), ErrorMessage);
2580 }
2581
2582 void CustomTrackView::cutSelectedClips() {
2583     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2584     GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
2585     for (int i = 0; i < itemList.count(); i++) {
2586         if (itemList.at(i)->type() == AVWIDGET) {
2587             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2588             if (currentPos > item->startPos() && currentPos <  item->endPos()) {
2589                 RazorClipCommand *command = new RazorClipCommand(this, item->info(), currentPos, true);
2590                 m_commandStack->push(command);
2591             }
2592         }
2593     }
2594 }
2595
2596 void CustomTrackView::groupClips(bool group) {
2597     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2598     QList <ItemInfo> clipInfos;
2599     QList <ItemInfo> transitionInfos;
2600     GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
2601
2602     // Expand groups
2603     int max = itemList.count();
2604     for (int i = 0; i < max; i++) {
2605         if (itemList.at(i)->type() == GROUPWIDGET) {
2606             itemList += itemList.at(i)->childItems();
2607         }
2608     }
2609
2610     for (int i = 0; i < itemList.count(); i++) {
2611         if (itemList.at(i)->type() == AVWIDGET) {
2612             AbstractClipItem *clip = static_cast <AbstractClipItem *>(itemList.at(i));
2613             if (!clip->isItemLocked()) clipInfos.append(clip->info());
2614         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
2615             AbstractClipItem *clip = static_cast <AbstractClipItem *>(itemList.at(i));
2616             if (!clip->isItemLocked()) transitionInfos.append(clip->info());
2617         }
2618     }
2619     if (clipInfos.count() > 0) {
2620         GroupClipsCommand *command = new GroupClipsCommand(this, clipInfos, transitionInfos, group, true);
2621         m_commandStack->push(command);
2622     }
2623 }
2624
2625 void CustomTrackView::doGroupClips(QList <ItemInfo> clipInfos, QList <ItemInfo> transitionInfos, bool group) {
2626     resetSelectionGroup();
2627     m_scene->clearSelection();
2628     if (!group) {
2629         for (int i = 0; i < clipInfos.count(); i++) {
2630             ClipItem *clip = getClipItemAt(clipInfos.at(i).startPos, clipInfos.at(i).track);
2631             if (clip == NULL) continue;
2632             if (clip->parentItem()) scene()->destroyItemGroup(static_cast <QGraphicsItemGroup *>(clip->parentItem()));
2633             clip->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
2634         }
2635         for (int i = 0; i < transitionInfos.count(); i++) {
2636             Transition *tr = getTransitionItemAt(transitionInfos.at(i).startPos, transitionInfos.at(i).track);
2637             if (tr == NULL) continue;
2638             if (tr->parentItem()) scene()->destroyItemGroup(static_cast <QGraphicsItemGroup *>(tr->parentItem()));
2639             tr->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
2640         }
2641         m_document->setModified(true);
2642         return;
2643     }
2644
2645     QList <QGraphicsItemGroup *> groups;
2646     for (int i = 0; i < clipInfos.count(); i++) {
2647         ClipItem *clip = getClipItemAt(clipInfos.at(i).startPos, clipInfos.at(i).track);
2648         if (clip) {
2649             clip->setSelected(true);
2650         }
2651     }
2652     for (int i = 0; i < transitionInfos.count(); i++) {
2653         Transition *clip = getTransitionItemAt(transitionInfos.at(i).startPos, transitionInfos.at(i).track);
2654         if (clip) {
2655             clip->setSelected(true);
2656         }
2657     }
2658
2659     groupSelectedItems(false, true);
2660     m_document->setModified(true);
2661 }
2662
2663 void CustomTrackView::addClip(QDomElement xml, const QString &clipId, ItemInfo info, EffectsList effects) {
2664     DocClipBase *baseclip = m_document->clipManager()->getClipById(clipId);
2665     if (baseclip == NULL) {
2666         emit displayMessage(i18n("No clip copied"), ErrorMessage);
2667         return;
2668     }
2669     ClipItem *item = new ClipItem(baseclip, info, m_document->fps(), xml.attribute("speed", "1").toDouble());
2670     item->setEffectList(effects);
2671     scene()->addItem(item);
2672
2673     int tracknumber = m_document->tracksCount() - info.track - 1;
2674     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2675     if (isLocked) item->setItemLocked(true);
2676
2677     if (item->baseClip()->isTransparent()) {
2678         // add transparency transition
2679         int endTrack = getPreviousVideoTrack(info.track);
2680         Transition *tr = new Transition(info, endTrack, m_document->fps(), MainWindow::transitions.getEffectByTag("composite", "composite"), true);
2681         if (m_document->renderer()->mltAddTransition(tr->transitionTag(), endTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML())) scene()->addItem(tr);
2682         else {
2683             emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
2684             delete tr;
2685         }
2686
2687     }
2688
2689     baseclip->addReference();
2690     m_document->updateClip(baseclip->getId());
2691     info.track = m_document->tracksCount() - info.track;
2692     m_document->renderer()->mltInsertClip(info, xml, baseclip->producer(info.track));
2693     for (int i = 0; i < item->effectsCount(); i++) {
2694         m_document->renderer()->mltAddEffect(info.track, info.startPos, item->getEffectArgs(item->effectAt(i)), false);
2695     }
2696     m_document->setModified(true);
2697     m_document->renderer()->doRefresh();
2698 }
2699
2700 void CustomTrackView::slotUpdateClip(const QString &clipId) {
2701     QList<QGraphicsItem *> list = scene()->items();
2702     ClipItem *clip = NULL;
2703     for (int i = 0; i < list.size(); ++i) {
2704         if (list.at(i)->type() == AVWIDGET) {
2705             clip = static_cast <ClipItem *>(list.at(i));
2706             if (clip->clipProducer() == clipId) {
2707                 clip->refreshClip();
2708                 ItemInfo info = clip->info();
2709                 info.track = m_document->tracksCount() - clip->track();
2710                 m_document->renderer()->mltUpdateClip(info, clip->xml(), clip->baseClip()->producer());
2711             }
2712         }
2713     }
2714 }
2715
2716 ClipItem *CustomTrackView::getClipItemAtEnd(GenTime pos, int track) {
2717     int framepos = (int)(pos.frames(m_document->fps()));
2718     QList<QGraphicsItem *> list = scene()->items(QPointF(framepos - 1, track * m_tracksHeight + m_tracksHeight / 2));
2719     ClipItem *clip = NULL;
2720     for (int i = 0; i < list.size(); i++) {
2721         if (list.at(i)->type() == AVWIDGET) {
2722             ClipItem *test = static_cast <ClipItem *>(list.at(i));
2723             if (test->endPos() == pos) clip = test;
2724             break;
2725         }
2726     }
2727     return clip;
2728 }
2729
2730 ClipItem *CustomTrackView::getClipItemAtStart(GenTime pos, int track) {
2731     QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), track * m_tracksHeight + m_tracksHeight / 2));
2732     ClipItem *clip = NULL;
2733     for (int i = 0; i < list.size(); i++) {
2734         if (list.at(i)->type() == AVWIDGET) {
2735             ClipItem *test = static_cast <ClipItem *>(list.at(i));
2736             if (test->startPos() == pos) clip = test;
2737             break;
2738         }
2739     }
2740     return clip;
2741 }
2742
2743 ClipItem *CustomTrackView::getClipItemAt(int pos, int track) {
2744     QList<QGraphicsItem *> list = scene()->items(QPointF(pos , track * m_tracksHeight + m_tracksHeight / 2));
2745     ClipItem *clip = NULL;
2746     for (int i = 0; i < list.size(); i++) {
2747         if (list.at(i)->type() == AVWIDGET) {
2748             clip = static_cast <ClipItem *>(list.at(i));
2749             break;
2750         }
2751     }
2752     return clip;
2753 }
2754
2755 ClipItem *CustomTrackView::getClipItemAt(GenTime pos, int track) {
2756     int framepos = (int)(pos.frames(m_document->fps()));
2757     return getClipItemAt(framepos, track);
2758 }
2759
2760 Transition *CustomTrackView::getTransitionItemAt(GenTime pos, int track) {
2761     QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), (track + 1) * m_tracksHeight));
2762     Transition *clip = NULL;
2763     for (int i = 0; i < list.size(); i++) {
2764         if (list.at(i)->type() == TRANSITIONWIDGET) {
2765             clip = static_cast <Transition *>(list.at(i));
2766             break;
2767         }
2768     }
2769     return clip;
2770 }
2771
2772 Transition *CustomTrackView::getTransitionItemAtEnd(GenTime pos, int track) {
2773     int framepos = (int)(pos.frames(m_document->fps()));
2774     QList<QGraphicsItem *> list = scene()->items(QPointF(framepos - 1, (track + 1) * m_tracksHeight));
2775     Transition *clip = NULL;
2776     for (int i = 0; i < list.size(); i++) {
2777         if (list.at(i)->type() == TRANSITIONWIDGET) {
2778             Transition *test = static_cast <Transition *>(list.at(i));
2779             if (test->endPos() == pos) clip = test;
2780             break;
2781         }
2782     }
2783     return clip;
2784 }
2785
2786 Transition *CustomTrackView::getTransitionItemAtStart(GenTime pos, int track) {
2787     QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), (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->startPos() == pos) clip = test;
2793             break;
2794         }
2795     }
2796     return clip;
2797 }
2798
2799 void CustomTrackView::moveClip(const ItemInfo start, const ItemInfo end) {
2800     if (m_selectionGroup) resetSelectionGroup(false);
2801     ClipItem *item = getClipItemAt((int) start.startPos.frames(m_document->fps()) + 1, start.track);
2802     if (!item) {
2803         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);
2804         kDebug() << "----------------  ERROR, CANNOT find clip to move at.. ";
2805         return;
2806     }
2807     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));
2808     if (success) {
2809         bool snap = KdenliveSettings::snaptopoints();
2810         KdenliveSettings::setSnaptopoints(false);
2811         item->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
2812
2813         int tracknumber = m_document->tracksCount() - end.track - 1;
2814         bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2815         m_scene->clearSelection();
2816         if (isLocked) item->setItemLocked(true);
2817         else {
2818             if (item->isItemLocked()) item->setItemLocked(false);
2819             item->setSelected(true);
2820         }
2821         if (item->baseClip()->isTransparent()) {
2822             // Also move automatic transition
2823             Transition *tr = getTransitionItemAt(start.startPos, start.track);
2824             if (tr && tr->isAutomatic()) {
2825                 tr->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
2826                 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);
2827                 tr->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
2828             }
2829         }
2830         KdenliveSettings::setSnaptopoints(snap);
2831         m_document->setModified(true);
2832     } else {
2833         // undo last move and emit error message
2834         emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(end.startPos.frames(m_document->fps()))), ErrorMessage);
2835     }
2836     kDebug() << " // MOVED CLIP TO: " << end.startPos.frames(25) << ", ITEM START: " << item->startPos().frames(25);
2837 }
2838
2839 void CustomTrackView::moveGroup(QList <ItemInfo> startClip, QList <ItemInfo> startTransition, const GenTime offset, const int trackOffset, bool reverseMove) {
2840     // Group Items
2841     kDebug() << "// GROUP MOVE; OFFSET: " << offset.frames(25) << ", TK OFF: " << trackOffset;
2842     resetSelectionGroup();
2843     m_scene->clearSelection();
2844     QList <QGraphicsItemGroup *> groups;
2845     for (int i = 0; i < startClip.count(); i++) {
2846         if (reverseMove) {
2847             startClip[i].startPos = startClip.at(i).startPos - offset;
2848             startClip[i].track = startClip.at(i).track - trackOffset;
2849         }
2850         ClipItem *clip = getClipItemAt(startClip.at(i).startPos, startClip.at(i).track);
2851         if (clip) {
2852             clip->setItemLocked(false);
2853             if (clip->parentItem()) clip->parentItem()->setSelected(true);
2854             else clip->setSelected(true);
2855             m_document->renderer()->mltRemoveClip(m_document->tracksCount() - startClip.at(i).track, startClip.at(i).startPos);
2856         }
2857     }
2858     for (int i = 0; i < startTransition.count(); i++) {
2859         if (reverseMove) {
2860             startTransition[i].startPos = startTransition.at(i).startPos - offset;
2861             startTransition[i].track = startTransition.at(i).track - trackOffset;
2862         }
2863         Transition *tr = getTransitionItemAt(startTransition.at(i).startPos, startTransition.at(i).track);
2864         if (tr) {
2865             tr->setItemLocked(false);
2866             if (tr->parentItem()) tr->parentItem()->setSelected(true);
2867             else tr->setSelected(true);
2868             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());
2869         }
2870     }
2871     groupSelectedItems(true);
2872     if (m_selectionGroup) {
2873         QPointF pos = m_selectionGroup->pos();
2874         qreal posx = pos.x() + offset.frames(m_document->fps());
2875         qreal posy = pos.y() + trackOffset * (qreal) m_tracksHeight;
2876         bool snap = KdenliveSettings::snaptopoints();
2877         KdenliveSettings::setSnaptopoints(false);
2878
2879         m_selectionGroup->setPos(posx, posy);
2880
2881         QPointF top = m_selectionGroup->sceneBoundingRect().topLeft();
2882         m_selectionGroup->setPos(top);
2883         m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
2884         m_selectionGroupInfo.track = m_selectionGroup->track();
2885
2886         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
2887         kDebug() << "// GRP MOVE; FOUND CHILDREN:" << children.count();
2888
2889         // Expand groups
2890         int max = children.count();
2891         for (int i = 0; i < max; i++) {
2892             if (children.at(i)->type() == GROUPWIDGET) {
2893                 children += children.at(i)->childItems();
2894             }
2895         }
2896         for (int i = 0; i < children.count(); i++) {
2897             // re-add items in correct place
2898             if (children.at(i)->type() != AVWIDGET && children.at(i)->type() != TRANSITIONWIDGET) continue;
2899             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
2900             item->updateItem();
2901             ItemInfo info = item->info();
2902             int tracknumber = m_document->tracksCount() - info.track - 1;
2903             bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2904             if (isLocked) item->setItemLocked(true);
2905             else if (item->isItemLocked()) item->setItemLocked(false);
2906
2907             if (item->type() == AVWIDGET) {
2908                 ClipItem *clip = static_cast <ClipItem*>(item);
2909                 info.track = m_document->tracksCount() - info.track;
2910                 m_document->renderer()->mltInsertClip(info, clip->xml(), clip->baseClip()->producer(info.track));
2911             } else {
2912                 Transition *tr = static_cast <Transition*>(item);
2913                 int newTrack = tr->transitionEndTrack();
2914                 kDebug() << "/// TRANSITION CURR TRK: " << newTrack;
2915                 if (!tr->forcedTrack()) {
2916                     newTrack += trackOffset;
2917                     if (newTrack < 0 || newTrack > m_document->tracksCount()) newTrack = getPreviousVideoTrack(info.track);
2918                 }
2919                 tr->updateTransitionEndTrack(newTrack);
2920                 kDebug() << "/// TRANSITION UPDATED TRK: " << newTrack;
2921                 m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2922             }
2923         }
2924         KdenliveSettings::setSnaptopoints(snap);
2925     }
2926
2927 }
2928
2929 void CustomTrackView::moveTransition(const ItemInfo start, const ItemInfo end) {
2930     Transition *item = getTransitionItemAt(start.startPos, start.track);
2931     if (!item) {
2932         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);
2933         kDebug() << "----------------  ERROR, CANNOT find transition to move... ";// << startPos.x() * m_scale * FRAME_SIZE + 1 << ", " << startPos.y() * m_tracksHeight + m_tracksHeight / 2;
2934         return;
2935     }
2936     //kDebug() << "----------------  Move TRANSITION FROM: " << startPos.x() << ", END:" << endPos.x() << ",TRACKS: " << oldtrack << " TO " << newtrack;
2937     bool snap = KdenliveSettings::snaptopoints();
2938     KdenliveSettings::setSnaptopoints(false);
2939     //kDebug()<<"///  RESIZE TRANS START: ("<< startPos.x()<<"x"<< startPos.y()<<") / ("<<endPos.x()<<"x"<< endPos.y()<<")";
2940     if (end.endPos - end.startPos == start.endPos - start.startPos) {
2941         // Transition was moved
2942         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
2943     } else if (end.endPos == start.endPos) {
2944         // Transition start resize
2945         item->resizeStart((int) end.startPos.frames(m_document->fps()));
2946     } else if (end.startPos == start.startPos) {
2947         // Transition end resize;
2948         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
2949     } else {
2950         // Move & resize
2951         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
2952         item->resizeStart((int) end.startPos.frames(m_document->fps()));
2953         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
2954     }
2955     //item->moveTransition(GenTime((int) (endPos.x() - startPos.x()), m_document->fps()));
2956     KdenliveSettings::setSnaptopoints(snap);
2957     item->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
2958     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);
2959 }
2960
2961 void CustomTrackView::resizeClip(const ItemInfo start, const ItemInfo end) {
2962     bool resizeClipStart = true;
2963     if (start.startPos == end.startPos) resizeClipStart = false;
2964     /*if (resizeClipStart) offset = 1;
2965     else offset = -1;*/
2966     ClipItem *item = getClipItemAt((int)(start.startPos.frames(m_document->fps())), start.track);
2967     if (!item) {
2968         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);
2969         kDebug() << "----------------  ERROR, CANNOT find clip to resize at... "; // << startPos;
2970         return;
2971     }
2972     if (item->parentItem()) {
2973         // Item is part of a group, reset group
2974         resetSelectionGroup();
2975     }
2976     bool snap = KdenliveSettings::snaptopoints();
2977     KdenliveSettings::setSnaptopoints(false);
2978     if (resizeClipStart && start.startPos != end.startPos) {
2979         ItemInfo clipinfo = item->info();
2980         clipinfo.track = m_document->tracksCount() - clipinfo.track;
2981         bool success = m_document->renderer()->mltResizeClipStart(clipinfo, end.startPos - item->startPos());
2982         if (success) {
2983             kDebug() << "RESIZE CLP STRAT TO:" << end.startPos.frames(m_document->fps()) << ", OLD ST: " << start.startPos.frames(25);
2984             item->resizeStart((int) end.startPos.frames(m_document->fps()));
2985             updateClipFade(item);
2986         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2987     } else if (!resizeClipStart) {
2988         ItemInfo clipinfo = item->info();
2989         clipinfo.track = m_document->tracksCount() - clipinfo.track;
2990         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, end.endPos - clipinfo.startPos);
2991         if (success) {
2992             item->resizeEnd((int) end.endPos.frames(m_document->fps()));
2993             updateClipFade(item, true);
2994         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2995     }
2996     if (end.cropStart != start.cropStart) {
2997         kDebug() << "// RESIZE CROP, DIFF: " << (end.cropStart - start.cropStart).frames(25);
2998         ItemInfo clipinfo = end;
2999         clipinfo.track = m_document->tracksCount() - end.track;
3000         bool success = m_document->renderer()->mltResizeClipCrop(clipinfo, end.cropStart - start.cropStart);
3001         if (success) {
3002             item->setCropStart(end.cropStart);
3003             item->resetThumbs();
3004         }
3005     }
3006     m_document->renderer()->doRefresh();
3007     KdenliveSettings::setSnaptopoints(snap);
3008 }
3009
3010 void CustomTrackView::updateClipFade(ClipItem * item, bool updateFadeOut) {
3011     if (!updateFadeOut) {
3012         int end = item->fadeIn();
3013         if (end != 0) {
3014             // there is a fade in effect
3015             int effectPos = item->hasEffect("volume", "fadein");
3016             if (effectPos != -1) {
3017                 QDomElement oldeffect = item->effectAt(effectPos);
3018                 int start = item->cropStart().frames(m_document->fps());
3019                 int max = item->cropDuration().frames(m_document->fps());
3020                 if (end > max) {
3021                     item->setFadeIn(max);
3022                     end = item->fadeIn();
3023                 }
3024                 end += start;
3025                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
3026                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
3027                 if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3028                     emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3029                 // if fade effect is displayed, update the effect edit widget with new clip duration
3030                 if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3031             }
3032             effectPos = item->hasEffect("brightness", "fade_from_black");
3033             if (effectPos != -1) {
3034                 QDomElement oldeffect = item->effectAt(effectPos);
3035                 int start = item->cropStart().frames(m_document->fps());
3036                 int max = item->cropDuration().frames(m_document->fps());
3037                 if (end > max) {
3038                     item->setFadeIn(max);
3039                     end = item->fadeIn();
3040                 }
3041                 end += start;
3042                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
3043                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
3044                 if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3045                     emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3046                 // if fade effect is displayed, update the effect edit widget with new clip duration
3047                 if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3048             }
3049         }
3050     } else {
3051         int start = item->fadeOut();
3052         if (start != 0) {
3053             // there is a fade in effect
3054             int effectPos = item->hasEffect("volume", "fadeout");
3055             if (effectPos != -1) {
3056                 QDomElement oldeffect = item->effectAt(effectPos);
3057                 int end = (item->duration() - item->cropStart()).frames(m_document->fps());
3058                 int max = item->cropDuration().frames(m_document->fps());
3059                 if (end > max) {
3060                     item->setFadeOut(max);
3061                     start = item->fadeOut();
3062                 }
3063                 start = end - start;
3064                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
3065                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
3066                 if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3067                     emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3068                 // if fade effect is displayed, update the effect edit widget with new clip duration
3069                 if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3070             }
3071             effectPos = item->hasEffect("brightness", "fade_to_black");
3072             if (effectPos != -1) {
3073                 QDomElement oldeffect = item->effectAt(effectPos);
3074                 int end = (item->duration() - item->cropStart()).frames(m_document->fps());
3075                 int max = item->cropDuration().frames(m_document->fps());
3076                 if (end > max) {
3077                     item->setFadeOut(max);
3078                     start = item->fadeOut();
3079                 }
3080                 start = end - start;
3081                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
3082                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
3083                 if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3084                     emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3085                 // if fade effect is displayed, update the effect edit widget with new clip duration
3086                 if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3087             }
3088         }
3089     }
3090 }
3091
3092 double CustomTrackView::getSnapPointForPos(double pos) {
3093     return m_scene->getSnapPointForPos(pos, KdenliveSettings::snaptopoints());
3094 }
3095
3096 void CustomTrackView::updateSnapPoints(AbstractClipItem *selected, QList <GenTime> offsetList, bool skipSelectedItems) {
3097     QList <GenTime> snaps;
3098     if (selected && offsetList.isEmpty()) offsetList.append(selected->duration());
3099     QList<QGraphicsItem *> itemList = items();
3100     for (int i = 0; i < itemList.count(); i++) {
3101         if (itemList.at(i) == selected) continue;
3102         if (skipSelectedItems && itemList.at(i)->isSelected()) continue;
3103         if (itemList.at(i)->type() == AVWIDGET) {
3104             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
3105             GenTime start = item->startPos();
3106             GenTime end = item->endPos();
3107             snaps.append(start);
3108             snaps.append(end);
3109             if (!offsetList.isEmpty()) {
3110                 for (int j = 0; j < offsetList.size(); j++) {
3111                     if (start > offsetList.at(j)) snaps.append(start - offsetList.at(j));
3112                     if (end > offsetList.at(j)) snaps.append(end - offsetList.at(j));
3113                 }
3114             }
3115             // Add clip markers
3116             QList < GenTime > markers = item->snapMarkers();
3117             for (int j = 0; j < markers.size(); ++j) {
3118                 GenTime t = markers.at(j);
3119                 snaps.append(t);
3120                 if (!offsetList.isEmpty()) {
3121                     for (int k = 0; k < offsetList.size(); k++) {
3122                         if (t > offsetList.at(k)) snaps.append(t - offsetList.at(k));
3123                     }
3124                 }
3125             }
3126         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
3127             Transition *transition = static_cast <Transition*>(itemList.at(i));
3128             GenTime start = transition->startPos();
3129             GenTime end = transition->endPos();
3130             snaps.append(start);
3131             snaps.append(end);
3132             if (!offsetList.isEmpty()) {
3133                 for (int j = 0; j < offsetList.size(); j++) {
3134                     if (start > offsetList.at(j)) snaps.append(start - offsetList.at(j));
3135                     if (end > offsetList.at(j)) snaps.append(end - offsetList.at(j));
3136                 }
3137             }
3138         }
3139     }
3140
3141     // add cursor position
3142     GenTime pos = GenTime(m_cursorPos, m_document->fps());
3143     snaps.append(pos);
3144     if (!offsetList.isEmpty()) {
3145         for (int j = 0; j < offsetList.size(); j++) {
3146             snaps.append(pos - offsetList.at(j));
3147         }
3148     }
3149
3150     // add guides
3151     for (int i = 0; i < m_guides.count(); i++) {
3152         snaps.append(m_guides.at(i)->position());
3153         if (!offsetList.isEmpty()) {
3154             for (int j = 0; j < offsetList.size(); j++) {
3155                 snaps.append(m_guides.at(i)->position() - offsetList.at(j));
3156             }
3157         }
3158     }
3159
3160     qSort(snaps);
3161     m_scene->setSnapList(snaps);
3162     //for (int i = 0; i < m_snapPoints.size(); ++i)
3163     //    kDebug() << "SNAP POINT: " << m_snapPoints.at(i).frames(25);
3164 }
3165
3166 void CustomTrackView::slotSeekToPreviousSnap() {
3167     updateSnapPoints(NULL);
3168     GenTime res = m_scene->previousSnapPoint(GenTime(m_cursorPos, m_document->fps()));
3169     setCursorPos((int) res.frames(m_document->fps()));
3170     checkScrolling();
3171 }
3172
3173 void CustomTrackView::slotSeekToNextSnap() {
3174     updateSnapPoints(NULL);
3175     GenTime res = m_scene->nextSnapPoint(GenTime(m_cursorPos, m_document->fps()));
3176     setCursorPos((int) res.frames(m_document->fps()));
3177     checkScrolling();
3178 }
3179
3180 void CustomTrackView::clipStart() {
3181     ClipItem *item = getMainActiveClip();
3182     if (item != NULL) {
3183         setCursorPos((int) item->startPos().frames(m_document->fps()));
3184         checkScrolling();
3185     }
3186 }
3187
3188 void CustomTrackView::clipEnd() {
3189     ClipItem *item = getMainActiveClip();
3190     if (item != NULL) {
3191         setCursorPos((int) item->endPos().frames(m_document->fps()) - 1);
3192         checkScrolling();
3193     }
3194 }
3195
3196 void CustomTrackView::slotAddClipMarker(const QString &id, GenTime t, QString c) {
3197     QString oldcomment = m_document->clipManager()->getClipById(id)->markerComment(t);
3198     AddMarkerCommand *command = new AddMarkerCommand(this, oldcomment, c, id, t, true);
3199     m_commandStack->push(command);
3200 }
3201
3202 void CustomTrackView::slotDeleteClipMarker(const QString &comment, const QString &id, const GenTime &position) {
3203     AddMarkerCommand *command = new AddMarkerCommand(this, comment, QString(), id, position, true);
3204     m_commandStack->push(command);
3205 }
3206
3207 void CustomTrackView::slotDeleteAllClipMarkers(const QString &id) {
3208     DocClipBase *base = m_document->clipManager()->getClipById(id);
3209     QList <CommentedTime> markers = base->commentedSnapMarkers();
3210
3211     if (markers.isEmpty()) {
3212         emit displayMessage(i18n("Clip has no markers"), ErrorMessage);
3213         return;
3214     }
3215     QUndoCommand *deleteMarkers = new QUndoCommand();
3216     deleteMarkers->setText("Delete clip markers");
3217
3218     for (int i = 0; i < markers.size(); i++) {
3219         new AddMarkerCommand(this, markers.at(i).comment(), QString(), id, markers.at(i).time(), true, deleteMarkers);
3220     }
3221     m_commandStack->push(deleteMarkers);
3222 }
3223
3224 void CustomTrackView::addMarker(const QString &id, const GenTime &pos, const QString comment) {
3225     DocClipBase *base = m_document->clipManager()->getClipById(id);
3226     if (!comment.isEmpty()) base->addSnapMarker(pos, comment);
3227     else base->deleteSnapMarker(pos);
3228     m_document->setModified(true);
3229     viewport()->update();
3230 }
3231
3232 bool sortGuidesList(const Guide *g1 , const Guide *g2) {
3233     return (*g1).position() < (*g2).position();
3234 }
3235
3236 void CustomTrackView::editGuide(const GenTime oldPos, const GenTime pos, const QString &comment) {
3237     if (oldPos > GenTime() && pos > GenTime()) {
3238         // move guide
3239         for (int i = 0; i < m_guides.count(); i++) {
3240             if (m_guides.at(i)->position() == oldPos) {
3241                 Guide *item = m_guides.at(i);
3242                 item->updateGuide(pos, comment);
3243                 break;
3244             }
3245         }
3246     } else if (pos > GenTime()) addGuide(pos, comment);
3247     else {
3248         // remove guide
3249         bool found = false;
3250         for (int i = 0; i < m_guides.count(); i++) {
3251             if (m_guides.at(i)->position() == oldPos) {
3252                 Guide *item = m_guides.takeAt(i);
3253                 delete item;
3254                 found = true;
3255                 break;
3256             }
3257         }
3258         if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
3259     }
3260     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
3261     m_document->syncGuides(m_guides);
3262 }
3263
3264 bool CustomTrackView::addGuide(const GenTime pos, const QString &comment) {
3265     for (int i = 0; i < m_guides.count(); i++) {
3266         if (m_guides.at(i)->position() == pos) {
3267             emit displayMessage(i18n("A guide already exists at position %1", m_document->timecode().getTimecodeFromFrames(pos.frames(m_document->fps()))), ErrorMessage);
3268             return false;
3269         }
3270     }
3271     Guide *g = new Guide(this, pos, comment, m_document->fps(), m_tracksHeight * m_document->tracksCount());
3272     scene()->addItem(g);
3273     m_guides.append(g);
3274     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
3275     m_document->syncGuides(m_guides);
3276     return true;
3277 }
3278
3279 void CustomTrackView::slotAddGuide() {
3280     CommentedTime marker(GenTime(m_cursorPos, m_document->fps()), i18n("Guide"));
3281     MarkerDialog d(NULL, marker, m_document->timecode(), i18n("Add Guide"), this);
3282     if (d.exec() != QDialog::Accepted) return;
3283     if (addGuide(d.newMarker().time(), d.newMarker().comment())) {
3284         EditGuideCommand *command = new EditGuideCommand(this, GenTime(), QString(), d.newMarker().time(), d.newMarker().comment(), false);
3285         m_commandStack->push(command);
3286     }
3287 }
3288
3289 void CustomTrackView::slotEditGuide() {
3290     GenTime pos = GenTime(m_cursorPos, m_document->fps());
3291     bool found = false;
3292     for (int i = 0; i < m_guides.count(); i++) {
3293         if (m_guides.at(i)->position() == pos) {
3294             slotEditGuide(m_guides.at(i)->info());
3295             found = true;
3296             break;
3297         }
3298     }
3299     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
3300 }
3301
3302 void CustomTrackView::slotEditGuide(CommentedTime guide) {
3303     MarkerDialog d(NULL, guide, m_document->timecode(), i18n("Edit Guide"), this);
3304     if (d.exec() == QDialog::Accepted) {
3305         EditGuideCommand *command = new EditGuideCommand(this, guide.time(), guide.comment(), d.newMarker().time(), d.newMarker().comment(), true);
3306         m_commandStack->push(command);
3307     }
3308 }
3309
3310
3311 void CustomTrackView::slotDeleteGuide() {
3312     GenTime pos = GenTime(m_cursorPos, m_document->fps());
3313     bool found = false;
3314     for (int i = 0; i < m_guides.count(); i++) {
3315         if (m_guides.at(i)->position() == pos) {
3316             EditGuideCommand *command = new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true);
3317             m_commandStack->push(command);
3318             found = true;
3319             break;
3320         }
3321     }
3322     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
3323 }
3324
3325 void CustomTrackView::slotDeleteAllGuides() {
3326     QUndoCommand *deleteAll = new QUndoCommand();
3327     deleteAll->setText("Delete all guides");
3328     for (int i = 0; i < m_guides.count(); i++) {
3329         new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true, deleteAll);
3330     }
3331     m_commandStack->push(deleteAll);
3332 }
3333
3334 void CustomTrackView::setTool(PROJECTTOOL tool) {
3335     m_tool = tool;
3336 }
3337
3338 void CustomTrackView::setScale(double scaleFactor) {
3339     QMatrix matrix;
3340     matrix = matrix.scale(scaleFactor, 1);
3341     m_scene->setScale(scaleFactor);
3342     //scale(scaleFactor, 1);
3343     m_animationTimer->stop();
3344     if (m_visualTip) {
3345         delete m_visualTip;
3346         m_visualTip = NULL;
3347     }
3348     if (m_animation) {
3349         delete m_animation;
3350         m_animation = NULL;
3351     }
3352
3353     //setSceneRect(0, 0, m_projectDuration + 100 * scaleFactor, sceneRect().height());
3354     setMatrix(matrix);
3355     int diff = sceneRect().width() - m_projectDuration;
3356     if (diff * matrix.m11() < 50) {
3357         if (matrix.m11() < 0.4) setSceneRect(0, 0, (m_projectDuration + 100 / matrix.m11()), sceneRect().height());
3358         else setSceneRect(0, 0, (m_projectDuration + 300), sceneRect().height());
3359     }
3360
3361     centerOn(QPointF(cursorPos(), m_tracksHeight));
3362     //verticalScrollBar()->setValue(vert);*/
3363 }
3364
3365 void CustomTrackView::slotRefreshGuides() {
3366     if (KdenliveSettings::showmarkers()) {
3367         kDebug() << "// refresh GUIDES";
3368         for (int i = 0; i < m_guides.count(); i++) {
3369             m_guides.at(i)->update();
3370         }
3371     }
3372 }
3373
3374 void CustomTrackView::drawBackground(QPainter * painter, const QRectF & rect) {
3375     QColor base = palette().button().color();
3376     QRectF r = rect;
3377     r.setWidth(r.width() + 1);
3378     painter->setClipRect(r);
3379     painter->drawLine(r.left(), 0, r.right(), 0);
3380     uint max = m_document->tracksCount();
3381     for (uint i = 0; i < max;i++) {
3382         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)));
3383         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)));
3384         painter->drawLine(r.left(), m_tracksHeight * (i + 1), r.right(), m_tracksHeight * (i + 1));
3385     }
3386     int lowerLimit = m_tracksHeight * m_document->tracksCount() + 1;
3387     if (height() > lowerLimit)
3388         painter->fillRect(QRectF(r.left(), lowerLimit, r.width(), height() - lowerLimit), QBrush(base));
3389 }
3390
3391 bool CustomTrackView::findString(const QString &text) {
3392     QString marker;
3393     for (int i = 0; i < m_searchPoints.size(); ++i) {
3394         marker = m_searchPoints.at(i).comment();
3395         if (marker.contains(text, Qt::CaseInsensitive)) {
3396             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
3397             int vert = verticalScrollBar()->value();
3398             int hor = cursorPos();
3399             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
3400             m_findIndex = i;
3401             return true;
3402         }
3403     }
3404     return false;
3405 }
3406
3407 bool CustomTrackView::findNextString(const QString &text) {
3408     QString marker;
3409     for (int i = m_findIndex + 1; i < m_searchPoints.size(); ++i) {
3410         marker = m_searchPoints.at(i).comment();
3411         if (marker.contains(text, Qt::CaseInsensitive)) {
3412             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
3413             int vert = verticalScrollBar()->value();
3414             int hor = cursorPos();
3415             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
3416             m_findIndex = i;
3417             return true;
3418         }
3419     }
3420     m_findIndex = -1;
3421     return false;
3422 }
3423
3424 void CustomTrackView::initSearchStrings() {
3425     m_searchPoints.clear();
3426     QList<QGraphicsItem *> itemList = items();
3427     for (int i = 0; i < itemList.count(); i++) {
3428         // parse all clip names
3429         if (itemList.at(i)->type() == AVWIDGET) {
3430             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
3431             GenTime start = item->startPos();
3432             CommentedTime t(start, item->clipName());
3433             m_searchPoints.append(t);
3434             // add all clip markers
3435             QList < CommentedTime > markers = item->commentedSnapMarkers();
3436             m_searchPoints += markers;
3437         }
3438     }
3439
3440     // add guides
3441     for (int i = 0; i < m_guides.count(); i++) {
3442         m_searchPoints.append(m_guides.at(i)->info());
3443     }
3444
3445     qSort(m_searchPoints);
3446 }
3447
3448 void CustomTrackView::clearSearchStrings() {
3449     m_searchPoints.clear();
3450     m_findIndex = 0;
3451 }
3452
3453 void CustomTrackView::copyClip() {
3454     while (m_copiedItems.count() > 0) {
3455         delete m_copiedItems.takeFirst();
3456     }
3457     QList<QGraphicsItem *> itemList = scene()->selectedItems();
3458     if (itemList.count() == 0) {
3459         emit displayMessage(i18n("Select a clip before copying"), ErrorMessage);
3460         return;
3461     }
3462     for (int i = 0; i < itemList.count(); i++) {
3463         if (itemList.at(i)->type() == AVWIDGET) {
3464             ClipItem *dup = static_cast <ClipItem *>(itemList.at(i));
3465             m_copiedItems.append(dup->clone(dup->info()));
3466         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
3467             Transition *dup = static_cast <Transition *>(itemList.at(i));
3468             m_copiedItems.append(dup->clone());
3469         }
3470     }
3471 }
3472
3473 bool CustomTrackView::canBePastedTo(ItemInfo info, int type) const {
3474     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));
3475     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
3476     for (int i = 0; i < collisions.count(); i++) {
3477         if (collisions.at(i)->type() == type) return false;
3478     }
3479     return true;
3480 }
3481
3482 bool CustomTrackView::canBePasted(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const {
3483     for (int i = 0; i < items.count(); i++) {
3484         ItemInfo info = items.at(i)->info();
3485         info.startPos += offset;
3486         info.endPos += offset;
3487         info.track += trackOffset;
3488         if (!canBePastedTo(info, items.at(i)->type())) return false;
3489     }
3490     return true;
3491 }
3492
3493 bool CustomTrackView::canBeMoved(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const {
3494     QPainterPath movePath;
3495     movePath.moveTo(0, 0);
3496
3497     for (int i = 0; i < items.count(); i++) {
3498         ItemInfo info = items.at(i)->info();
3499         info.startPos = info.startPos + offset;
3500         info.endPos = info.endPos + offset;
3501         info.track = info.track + trackOffset;
3502         if (info.startPos < GenTime()) {
3503             // No clip should go below 0
3504             return false;
3505         }
3506         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));
3507         movePath.addRect(rect);
3508     }
3509     QList<QGraphicsItem *> collisions = scene()->items(movePath, Qt::IntersectsItemBoundingRect);
3510     for (int i = 0; i < collisions.count(); i++) {
3511         if ((collisions.at(i)->type() == AVWIDGET || collisions.at(i)->type() == TRANSITIONWIDGET) && !items.contains(static_cast <AbstractClipItem *>(collisions.at(i)))) {
3512             kDebug() << "  ////////////   CLIP COLLISION, MOVE NOT ALLOWED";
3513             return false;
3514         }
3515     }
3516     return true;
3517 }
3518
3519 void CustomTrackView::pasteClip() {
3520     if (m_copiedItems.count() == 0) {
3521         emit displayMessage(i18n("No clip copied"), ErrorMessage);
3522         return;
3523     }
3524     QPoint position;
3525     if (m_menuPosition.isNull()) {
3526         position = mapFromGlobal(QCursor::pos());
3527         if (!underMouse() || position.y() > m_tracksHeight * m_document->tracksCount()) {
3528             emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
3529             return;
3530         }
3531     } else position = m_menuPosition;
3532     GenTime pos = GenTime((int)(mapToScene(position).x()), m_document->fps());
3533     int track = (int)(position.y() / m_tracksHeight);
3534     ItemInfo first = m_copiedItems.at(0)->info();
3535
3536     GenTime offset = pos - first.startPos;
3537     int trackOffset = track - first.track;
3538
3539     if (!canBePasted(m_copiedItems, offset, trackOffset)) {
3540         emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
3541         return;
3542     }
3543     QUndoCommand *pasteClips = new QUndoCommand();
3544     pasteClips->setText("Paste clips");
3545
3546     for (int i = 0; i < m_copiedItems.count(); i++) {
3547         // parse all clip names
3548         if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == AVWIDGET) {
3549             ClipItem *clip = static_cast <ClipItem *>(m_copiedItems.at(i));
3550             ItemInfo info;
3551             info.startPos = clip->startPos() + offset;
3552             info.endPos = clip->endPos() + offset;
3553             info.cropStart = clip->cropStart();
3554             info.track = clip->track() + trackOffset;
3555             if (canBePastedTo(info, AVWIDGET)) {
3556                 new AddTimelineClipCommand(this, clip->xml(), clip->clipProducer(), info, clip->effectList(), true, false, pasteClips);
3557             } else emit displayMessage(i18n("Cannot paste clip to selected place"), ErrorMessage);
3558         } else if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == TRANSITIONWIDGET) {
3559             Transition *tr = static_cast <Transition *>(m_copiedItems.at(i));
3560             ItemInfo info;
3561             info.startPos = tr->startPos() + offset;
3562             info.endPos = tr->endPos() + offset;
3563             info.track = tr->track() + trackOffset;
3564             if (canBePastedTo(info, TRANSITIONWIDGET)) {
3565                 if (info.startPos >= info.endPos) {
3566                     emit displayMessage(i18n("Invalid transition"), ErrorMessage);
3567                 } else new AddTransitionCommand(this, info, tr->transitionEndTrack() + trackOffset, tr->toXML(), false, true, pasteClips);
3568             } else emit displayMessage(i18n("Cannot paste transition to selected place"), ErrorMessage);
3569         }
3570     }
3571     m_commandStack->push(pasteClips);
3572 }
3573
3574 void CustomTrackView::pasteClipEffects() {
3575     if (m_copiedItems.count() != 1 || m_copiedItems.at(0)->type() != AVWIDGET) {
3576         emit displayMessage(i18n("You must copy exactly one clip before pasting effects"), ErrorMessage);
3577         return;
3578     }
3579     ClipItem *clip = static_cast < ClipItem *>(m_copiedItems.at(0));
3580     EffectsList effects = clip->effectList();
3581
3582     QUndoCommand *paste = new QUndoCommand();
3583     paste->setText("Paste effects");
3584
3585     QList<QGraphicsItem *> clips = scene()->selectedItems();
3586     for (int i = 0; i < clips.count(); ++i) {
3587         if (clips.at(i)->type() == AVWIDGET) {
3588             ClipItem *item = static_cast < ClipItem *>(clips.at(i));
3589             for (int i = 0; i < clip->effectsCount(); i++) {
3590                 new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), clip->effectAt(i), true, paste);
3591             }
3592         }
3593     }
3594     m_commandStack->push(paste);
3595 }
3596
3597
3598 ClipItem *CustomTrackView::getClipUnderCursor() const {
3599     QRectF rect((double) m_cursorPos, 0.0, 1.0, (double)(m_tracksHeight * m_document->tracksCount()));
3600     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
3601     for (int i = 0; i < collisions.count(); i++) {
3602         if (collisions.at(i)->type() == AVWIDGET) {
3603             return static_cast < ClipItem *>(collisions.at(i));
3604         }
3605     }
3606     return NULL;
3607 }
3608
3609 ClipItem *CustomTrackView::getMainActiveClip() const {
3610     QList<QGraphicsItem *> clips = scene()->selectedItems();
3611     if (clips.isEmpty()) {
3612         return getClipUnderCursor();
3613     } else {
3614         ClipItem *item = NULL;
3615         for (int i = 0; i < clips.count(); ++i) {
3616             if (clips.at(i)->type() == AVWIDGET)
3617                 item = static_cast < ClipItem *>(clips.at(i));
3618             if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos) break;
3619         }
3620         if (item) return item;
3621     }
3622     return NULL;
3623 }
3624
3625 ClipItem *CustomTrackView::getActiveClipUnderCursor(bool allowOutsideCursor) const {
3626     QList<QGraphicsItem *> clips = scene()->selectedItems();
3627     if (clips.isEmpty()) {
3628         return getClipUnderCursor();
3629     } else {
3630         ClipItem *item;
3631         // remove all items in the list that are not clips
3632         for (int i = 0; i < clips.count();) {
3633             if (clips.at(i)->type() != AVWIDGET) clips.removeAt(i);
3634             else i++;
3635         }
3636         if (clips.count() == 1 && allowOutsideCursor) return static_cast < ClipItem *>(clips.at(0));
3637         for (int i = 0; i < clips.count(); ++i) {
3638             if (clips.at(i)->type() == AVWIDGET) {
3639                 item = static_cast < ClipItem *>(clips.at(i));
3640                 if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos)
3641                     return item;
3642             }
3643         }
3644     }
3645     return NULL;
3646 }
3647
3648 void CustomTrackView::setInPoint() {
3649     ClipItem *clip = getActiveClipUnderCursor(true);
3650     if (clip == NULL) {
3651         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
3652         return;
3653     }
3654     ItemInfo startInfo = clip->info();
3655     ItemInfo endInfo = startInfo;
3656     endInfo.startPos = GenTime(m_cursorPos, m_document->fps());
3657     if (endInfo.startPos >= startInfo.endPos) {
3658         // Check for invalid resize
3659         emit displayMessage(i18n("Invalid action"), ErrorMessage);
3660         return;
3661     } else if (endInfo.startPos < startInfo.startPos) {
3662         int length = m_document->renderer()->mltGetSpaceLength(endInfo.startPos, m_document->tracksCount() - startInfo.track, false);
3663         if (length < (startInfo.startPos - endInfo.startPos).frames(m_document->fps())) {
3664             emit displayMessage(i18n("Invalid action"), ErrorMessage);
3665             return;
3666         }
3667     }
3668     ResizeClipCommand *command = new ResizeClipCommand(this, startInfo, endInfo, true);
3669     m_commandStack->push(command);
3670 }
3671
3672 void CustomTrackView::setOutPoint() {
3673     ClipItem *clip = getActiveClipUnderCursor(true);
3674     if (clip == NULL) {
3675         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
3676         return;
3677     }
3678     ItemInfo startInfo = clip->info();
3679     ItemInfo endInfo = clip->info();
3680     endInfo.endPos = GenTime(m_cursorPos, m_document->fps());
3681     if (endInfo.endPos <= startInfo.startPos) {
3682         // Check for invalid resize
3683         emit displayMessage(i18n("Invalid action"), ErrorMessage);
3684         return;
3685     } else if (endInfo.endPos > startInfo.endPos) {
3686         int length = m_document->renderer()->mltGetSpaceLength(endInfo.endPos, m_document->tracksCount() - startInfo.track, false);
3687         if (length < (endInfo.endPos - startInfo.endPos).frames(m_document->fps())) {
3688             emit displayMessage(i18n("Invalid action"), ErrorMessage);
3689             return;
3690         }
3691     }
3692
3693
3694
3695     ResizeClipCommand *command = new ResizeClipCommand(this, startInfo, endInfo, true);
3696     m_commandStack->push(command);
3697 }
3698
3699 void CustomTrackView::slotUpdateAllThumbs() {
3700     QList<QGraphicsItem *> itemList = items();
3701     //if (itemList.isEmpty()) return;
3702     ClipItem *item;
3703     QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
3704     for (int i = 0; i < itemList.count(); i++) {
3705         if (itemList.at(i)->type() == AVWIDGET) {
3706             item = static_cast <ClipItem *>(itemList.at(i));
3707             if (item->clipType() != COLOR) {
3708                 // Check if we have a cached thumbnail
3709                 if (item->clipType() == IMAGE || item->clipType() == TEXT || item->clipType() == AUDIO) {
3710                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
3711                     if (QFile::exists(thumb)) {
3712                         QPixmap pix(thumb);
3713                         item->slotSetStartThumb(pix);
3714                         item->slotSetEndThumb(pix);
3715                     }
3716                 } else {
3717                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
3718                     QString endThumb = startThumb;
3719                     startThumb.append(QString::number(item->cropStart().frames(m_document->fps())) + ".png");
3720                     endThumb.append(QString::number((item->cropStart() + item->cropDuration()).frames(m_document->fps()) - 1) + ".png");
3721                     if (QFile::exists(startThumb)) {
3722                         QPixmap pix(startThumb);
3723                         item->slotSetStartThumb(pix);
3724                     }
3725                     if (QFile::exists(endThumb)) {
3726                         QPixmap pix(endThumb);
3727                         item->slotSetEndThumb(pix);
3728                     }
3729                 }
3730             }
3731             item->refreshClip();
3732             qApp->processEvents();
3733         }
3734     }
3735     viewport()->update();
3736 }
3737
3738 void CustomTrackView::saveThumbnails() {
3739     QList<QGraphicsItem *> itemList = items();
3740     ClipItem *item;
3741     QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
3742     for (int i = 0; i < itemList.count(); i++) {
3743         if (itemList.at(i)->type() == AVWIDGET) {
3744             item = static_cast <ClipItem *>(itemList.at(i));
3745             if (item->clipType() != COLOR) {
3746                 // Check if we have a cached thumbnail
3747                 if (item->clipType() == IMAGE || item->clipType() == TEXT || item->clipType() == AUDIO) {
3748                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
3749                     if (!QFile::exists(thumb)) {
3750                         QPixmap pix(item->startThumb());
3751                         pix.save(thumb);
3752                     }
3753                 } else {
3754                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
3755                     QString endThumb = startThumb;
3756                     startThumb.append(QString::number(item->cropStart().frames(m_document->fps())) + ".png");
3757                     endThumb.append(QString::number((item->cropStart() + item->cropDuration()).frames(m_document->fps()) - 1) + ".png");
3758                     if (!QFile::exists(startThumb)) {
3759                         QPixmap pix(item->startThumb());
3760                         pix.save(startThumb);
3761                     }
3762                     if (!QFile::exists(endThumb)) {
3763                         QPixmap pix(item->endThumb());
3764                         pix.save(endThumb);
3765                     }
3766                 }
3767             }
3768         }
3769     }
3770 }
3771
3772
3773 void CustomTrackView::slotInsertTrack(int ix) {
3774     kDebug() << "// INSERTING TRK: " << ix;
3775     QDialog d(parentWidget());
3776     Ui::AddTrack_UI view;
3777     view.setupUi(&d);
3778     view.track_nb->setMaximum(m_document->tracksCount() - 1);
3779     view.track_nb->setValue(ix);
3780     d.setWindowTitle(i18n("Insert Track"));
3781
3782     if (d.exec() == QDialog::Accepted) {
3783         ix = view.track_nb->value();
3784         if (view.before_select->currentIndex() == 1) {
3785             ix++;
3786         }
3787         TrackInfo info;
3788         if (view.video_track->isChecked()) {
3789             info.type = VIDEOTRACK;
3790             info.isMute = false;
3791             info.isBlind = false;
3792             info.isLocked = false;
3793         } else {
3794             info.type = AUDIOTRACK;
3795             info.isMute = false;
3796             info.isBlind = true;
3797             info.isLocked = false;
3798         }
3799         AddTrackCommand *addTrack = new AddTrackCommand(this, ix, info, true, true);
3800         m_commandStack->push(addTrack);
3801         m_document->setModified(true);
3802     }
3803 }
3804
3805 void CustomTrackView::slotDeleteTrack(int ix) {
3806     bool ok;
3807     ix = QInputDialog::getInteger(this, i18n("Remove Track"), i18n("Track"), ix, 0, m_document->tracksCount() - 1, 1, &ok);
3808     if (ok) {
3809         TrackInfo info = m_document->trackInfoAt(m_document->tracksCount() - ix - 1);
3810         deleteTimelineTrack(ix, info);
3811         m_document->setModified(true);
3812         /*AddTrackCommand* command = new AddTrackCommand(this, ix, info, false, true);
3813         m_commandStack->push(command);*/
3814     }
3815 }
3816
3817 void CustomTrackView::slotChangeTrack(int ix) {
3818     QDialog d(parentWidget());
3819     Ui::AddTrack_UI view;
3820     view.setupUi(&d);
3821     view.label->setText(i18n("Change track"));
3822     view.before_select->setHidden(true);
3823     view.track_nb->setMaximum(m_document->tracksCount() - 1);
3824     view.track_nb->setValue(ix);
3825     d.setWindowTitle(i18n("Change Track Type"));
3826
3827     if (d.exec() == QDialog::Accepted) {
3828         TrackInfo info;
3829         info.isLocked = false;
3830         info.isMute = false;
3831         ix = view.track_nb->value();
3832
3833         if (view.video_track->isChecked()) {
3834             info.type = VIDEOTRACK;
3835             info.isBlind = false;
3836         } else {
3837             info.type = AUDIOTRACK;
3838             info.isBlind = true;
3839         }
3840         changeTimelineTrack(ix, info);
3841         m_document->setModified(true);
3842     }
3843 }
3844
3845
3846 void CustomTrackView::deleteTimelineTrack(int ix, TrackInfo trackinfo) {
3847     double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
3848     QRectF r(0, startY, sceneRect().width(), m_tracksHeight / 2 - 1);
3849     QList<QGraphicsItem *> selection = m_scene->items(r);
3850     QUndoCommand *deleteTrack = new QUndoCommand();
3851     deleteTrack->setText("Delete track");
3852
3853     // Delete all clips in selected track
3854     for (int i = 0; i < selection.count(); i++) {
3855         if (selection.at(i)->type() == AVWIDGET) {
3856             ClipItem *item =  static_cast <ClipItem *>(selection.at(i));
3857             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, true, deleteTrack);
3858             m_scene->removeItem(item);
3859             delete item;
3860             item = NULL;
3861         } else if (selection.at(i)->type() == TRANSITIONWIDGET) {
3862             Transition *item =  static_cast <Transition *>(selection.at(i));
3863             new AddTransitionCommand(this, item->info(), item->transitionEndTrack(), item->toXML(), true, false, deleteTrack);
3864             m_scene->removeItem(item);
3865             delete item;
3866             item = NULL;
3867         }
3868     }
3869
3870     new AddTrackCommand(this, ix, trackinfo, false, true, deleteTrack);
3871     m_commandStack->push(deleteTrack);
3872 }
3873
3874 void CustomTrackView::changeTimelineTrack(int ix, TrackInfo trackinfo) {
3875     TrackInfo oldinfo = m_document->trackInfoAt(m_document->tracksCount() - ix - 1);
3876     ChangeTrackCommand *changeTrack = new ChangeTrackCommand(this, ix, oldinfo, trackinfo, true);
3877     m_commandStack->push(changeTrack);
3878 }
3879
3880 void CustomTrackView::autoTransition() {
3881     QList<QGraphicsItem *> itemList = scene()->selectedItems();
3882     if (itemList.count() != 1 || itemList.at(0)->type() != TRANSITIONWIDGET) {
3883         emit displayMessage(i18n("You must select one transition for this action"), ErrorMessage);
3884         return;
3885     }
3886     Transition *tr = static_cast <Transition*>(itemList.at(0));
3887     tr->setAutomatic(!tr->isAutomatic());
3888     QDomElement transition = tr->toXML();
3889     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);
3890 }
3891
3892
3893 QStringList CustomTrackView::getLadspaParams(QDomElement effect) const {
3894     QStringList result;
3895     QDomNodeList params = effect.elementsByTagName("parameter");
3896     for (int i = 0; i < params.count(); i++) {
3897         QDomElement e = params.item(i).toElement();
3898         if (!e.isNull() && e.attribute("type") == "constant") {
3899             if (e.hasAttribute("factor")) {
3900                 double factor = e.attribute("factor").toDouble();
3901                 double value = e.attribute("value").toDouble();
3902                 value = value / factor;
3903                 result.append(QString::number(value));
3904             } else result.append(e.attribute("value"));
3905         }
3906     }
3907     return result;
3908 }
3909
3910 void CustomTrackView::clipNameChanged(const QString id, const QString name) {
3911     QList<QGraphicsItem *> list = scene()->items();
3912     ClipItem *clip = NULL;
3913     for (int i = 0; i < list.size(); ++i) {
3914         if (list.at(i)->type() == AVWIDGET) {
3915             clip = static_cast <ClipItem *>(list.at(i));
3916             if (clip->clipProducer() == id) {
3917                 clip->setClipName(name);
3918             }
3919         }
3920     }
3921     viewport()->update();
3922 }
3923
3924 void CustomTrackView::getClipAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum) {
3925     minimum = GenTime();
3926     maximum = GenTime();
3927     QList<QGraphicsItem *> selection;
3928     selection = m_scene->items(0, item->track() * m_tracksHeight + m_tracksHeight / 2, sceneRect().width(), 2);
3929     selection.removeAll(item);
3930     for (int i = 0; i < selection.count(); i++) {
3931         AbstractClipItem *clip = static_cast <AbstractClipItem *>(selection.at(i));
3932         if (clip && clip->type() == AVWIDGET) {
3933             if (clip->endPos() <= item->startPos() && clip->endPos() > minimum) minimum = clip->endPos();
3934             if (clip->startPos() > item->startPos() && (clip->startPos() < maximum || maximum == GenTime())) maximum = clip->startPos();
3935         }
3936     }
3937 }
3938
3939 void CustomTrackView::getTransitionAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum) {
3940     minimum = GenTime();
3941     maximum = GenTime();
3942     QList<QGraphicsItem *> selection;
3943     selection = m_scene->items(0, (item->track() + 1) * m_tracksHeight, sceneRect().width(), 2);
3944     selection.removeAll(item);
3945     for (int i = 0; i < selection.count(); i++) {
3946         AbstractClipItem *clip = static_cast <AbstractClipItem *>(selection.at(i));
3947         if (clip && clip->type() == TRANSITIONWIDGET) {
3948             if (clip->endPos() <= item->startPos() && clip->endPos() > minimum) minimum = clip->endPos();
3949             if (clip->startPos() > item->startPos() && (clip->startPos() < maximum || maximum == GenTime())) maximum = clip->startPos();
3950         }
3951     }
3952 }
3953
3954 void CustomTrackView::syncGroups() {
3955     // create groups list
3956     QList<QGraphicsItem*> items = scene()->items();
3957     int i = 0;
3958     while (i < items.count()) {
3959         if (items.at(i)->type() != GROUPWIDGET) items.removeAt(i);
3960         else i++;
3961     }
3962     m_document->clipManager()->setGroups(items);
3963 }
3964
3965 #include "customtrackview.moc"