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 #include <QMouseEvent>
  21 #include <QStylePainter>
  22 #include <QGraphicsItem>
  23 #include <QDomDocument>
  24 #include <QScrollBar>
  25 #include <QApplication>
  26 #include <QInputDialog>
  27
  28 #include <KDebug>
  29 #include <KLocale>
  30 #include <KUrl>
  31 #include <KIcon>
  32 #include <KCursor>
  33
  34 #include "customtrackview.h"
  35 #include "customtrackscene.h"
  36 #include "docclipbase.h"
  37 #include "clipitem.h"
  38 #include "definitions.h"
  39 #include "moveclipcommand.h"
  40 #include "movetransitioncommand.h"
  41 #include "resizeclipcommand.h"
  42 #include "editguidecommand.h"
  43 #include "addtimelineclipcommand.h"
  44 #include "addeffectcommand.h"
  45 #include "editeffectcommand.h"
  46 #include "moveeffectcommand.h"
  47 #include "addtransitioncommand.h"
  48 #include "edittransitioncommand.h"
  49 #include "editkeyframecommand.h"
  50 #include "changespeedcommand.h"
  51 #include "addmarkercommand.h"
  52 #include "razorclipcommand.h"
  53 #include "kdenlivesettings.h"
  54 #include "transition.h"
  55 #include "clipitem.h"
  56 #include "customtrackview.h"
  57 #include "clipmanager.h"
  58 #include "renderer.h"
  59 #include "markerdialog.h"
  60 #include "mainwindow.h"
  61 #include "ui_keyframedialog_ui.h"
  62 #include "clipdurationdialog.h"
  63 #include "abstractgroupitem.h"
  64 #include "insertspacecommand.h"
  65 #include "spacerdialog.h"
  66 #include "addtrackcommand.h"
  67 #include "changetrackcommand.h"
  68 #include "movegroupcommand.h"
  69 #include "ui_addtrack_ui.h"
  70
  71 //TODO:
  72 // disable animation if user asked it in KDE's global settings
  73 // http://lists.kde.org/?l=kde-commits&m=120398724717624&w=2
  74 // needs something like below (taken from dolphin)
  75 // #include <kglobalsettings.h>
  76 // const bool animate = KGlobalSettings::graphicEffectsLevel() & KGlobalSettings::SimpleAnimationEffects;
  77 // const int duration = animate ? 1500 : 1;
  78
  79 CustomTrackView::CustomTrackView(KdenliveDoc *doc, CustomTrackScene* projectscene, QWidget *parent)
  80         : 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) {
  81     if (doc) m_commandStack = doc->commandStack();
  82     else m_commandStack == NULL;
  83     setMouseTracking(true);
  84     setAcceptDrops(true);
  85     m_animationTimer = new QTimeLine(800);
  86     m_animationTimer->setFrameRange(0, 5);
  87     m_animationTimer->setUpdateInterval(100);
  88     m_animationTimer->setLoopCount(0);
  89     m_tipColor = QColor(0, 192, 0, 200);
  90     QColor border = QColor(255, 255, 255, 100);
  91     m_tipPen.setColor(border);
  92     m_tipPen.setWidth(3);
  93     setContentsMargins(0, 0, 0, 0);
  94     const int maxWidth = m_tracksHeight * m_document->tracksCount();
  95     setSceneRect(0, 0, sceneRect().width(), maxWidth);
  96     verticalScrollBar()->setMaximum(maxWidth);
  97     m_cursorLine = projectscene->addLine(0, 0, 0, maxWidth);
  98     m_cursorLine->setZValue(1000);
  99
 100     KIcon razorIcon("edit-cut");
 101     m_razorCursor = QCursor(razorIcon.pixmap(22, 22));
 102
 103     KIcon spacerIcon("kdenlive-spacer-tool");
 104     m_spacerCursor = QCursor(spacerIcon.pixmap(22, 22));
 105     verticalScrollBar()->setTracking(true);
 106     connect(verticalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(slotRefreshGuides()));
 107     connect(&m_scrollTimer, SIGNAL(timeout()), this, SLOT(slotCheckMouseScrolling()));
 108     m_scrollTimer.setInterval(100);
 109     m_scrollTimer.setSingleShot(true);
 110 }
 111
 112 CustomTrackView::~CustomTrackView() {
 113     qDeleteAll(m_guides);
 114 }
 115
 116 void CustomTrackView::setDocumentModified() {
 117     m_document->setModified(true);
 118 }
 119
 120 void CustomTrackView::setContextMenu(QMenu *timeline, QMenu *clip, QMenu *transition) {
 121     m_timelineContextMenu = timeline;
 122     m_timelineContextClipMenu = clip;
 123     m_timelineContextTransitionMenu = transition;
 124 }
 125
 126 void CustomTrackView::checkAutoScroll() {
 127     m_autoScroll = KdenliveSettings::autoscroll();
 128 }
 129
 130 /*sQList <TrackInfo> CustomTrackView::tracksList() const {
 131     return m_scene->m_tracksList;
 132 }*/
 133
 134 void CustomTrackView::checkTrackHeight() {
 135     if (m_tracksHeight == KdenliveSettings::trackheight()) return;
 136     m_tracksHeight = KdenliveSettings::trackheight();
 137     emit trackHeightChanged();
 138     QList<QGraphicsItem *> itemList = items();
 139     ClipItem *item;
 140     Transition *transitionitem;
 141     for (int i = 0; i < itemList.count(); i++) {
 142         if (itemList.at(i)->type() == AVWIDGET) {
 143             item = (ClipItem*) itemList.at(i);
 144             item->setRect(0, 0, item->rect().width(), m_tracksHeight - 1);
 145             item->setPos((qreal) item->startPos().frames(m_document->fps()), (qreal) item->track() * m_tracksHeight + 1);
 146             item->resetThumbs();
 147         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
 148             transitionitem = (Transition*) itemList.at(i);
 149             transitionitem->setRect(0, 0, transitionitem->rect().width(), m_tracksHeight / 3 * 2 - 1);
 150             transitionitem->setPos((qreal) transitionitem->startPos().frames(m_document->fps()), (qreal) transitionitem->track() * m_tracksHeight + m_tracksHeight / 3 * 2);
 151         }
 152     }
 153     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), m_tracksHeight * m_document->tracksCount());
 154
 155     for (int i = 0; i < m_guides.count(); i++) {
 156         QLineF l = m_guides.at(i)->line();
 157         l.setP2(QPointF(l.x2(), m_tracksHeight * m_document->tracksCount()));
 158         m_guides.at(i)->setLine(l);
 159     }
 160
 161     setSceneRect(0, 0, sceneRect().width(), m_tracksHeight * m_document->tracksCount());
 162     verticalScrollBar()->setMaximum(m_tracksHeight * m_document->tracksCount());
 163     update();
 164 }
 165
 166 // virtual
 167 void CustomTrackView::resizeEvent(QResizeEvent * event) {
 168     QGraphicsView::resizeEvent(event);
 169 }
 170
 171 // virtual
 172 /** Zoom or move viewport on mousewheel
 173  *
 174  * If mousewheel+Ctrl, zooms in/out on the timeline.
 175  *
 176  * With Ctrl, moves viewport towards end of timeline if down/back,
 177  * opposite on up/forward.
 178  *
 179  * See also http://www.kdenlive.org/mantis/view.php?id=265 */
 180 void CustomTrackView::wheelEvent(QWheelEvent * e) {
 181     if (e->modifiers() == Qt::ControlModifier) {
 182         if (e->delta() > 0) emit zoomIn();
 183         else emit zoomOut();
 184     } else {
 185         if (e->delta() <= 0) horizontalScrollBar()->setValue(horizontalScrollBar()->value() + horizontalScrollBar()->singleStep());
 186         else  horizontalScrollBar()->setValue(horizontalScrollBar()->value() - horizontalScrollBar()->singleStep());
 187     }
 188 }
 189
 190 int CustomTrackView::getPreviousVideoTrack(int track) {
 191     track = m_document->tracksCount() - track - 1;
 192     track --;
 193     for (int i = track; i > -1; i--) {
 194         if (m_document->trackInfoAt(i).type == VIDEOTRACK) return i + 1;
 195     }
 196     return 0;
 197 }
 198
 199
 200 void CustomTrackView::slotCheckMouseScrolling() {
 201     if (m_scrollOffset == 0) {
 202         m_scrollTimer.stop();
 203         return;
 204     }
 205     horizontalScrollBar()->setValue(horizontalScrollBar()->value() + m_scrollOffset);
 206     m_scrollTimer.start();
 207 }
 208
 209 void CustomTrackView::slotCheckPositionScrolling() {
 210     // If mouse is at a border of the view, scroll
 211     if (m_moveOpMode != SEEK) return;
 212     int pos = cursorPos();
 213     if (mapFromScene(pos, 0).x() < 7) {
 214         horizontalScrollBar()->setValue(horizontalScrollBar()->value() - 2);
 215         setCursorPos(mapToScene(QPoint()).x() - 1);
 216         QTimer::singleShot(200, this, SLOT(slotCheckPositionScrolling()));
 217
 218     } else if (viewport()->width() - 5 < mapFromScene(pos + 1, 0).x()) {
 219         horizontalScrollBar()->setValue(horizontalScrollBar()->value() + 2);
 220         setCursorPos(mapToScene(viewport()->width(), 0).x() + 1);
 221         QTimer::singleShot(200, this, SLOT(slotCheckPositionScrolling()));
 222     }
 223 }
 224
 225
 226 // virtual
 227
 228 void CustomTrackView::mouseMoveEvent(QMouseEvent * event) {
 229     int pos = event->x();
 230     int mappedXPos = (int)(mapToScene(event->pos()).x() + 0.5);
 231     emit mousePosition(mappedXPos);
 232     if (event->buttons() & Qt::MidButton) return;
 233     if ((event->modifiers() == Qt::ControlModifier && m_tool != SPACERTOOL) || event->modifiers() == Qt::ShiftModifier) {
 234         QGraphicsView::mouseMoveEvent(event);
 235         m_moveOpMode = NONE;
 236         return;
 237     }
 238
 239     if (event->buttons() != Qt::NoButton) {
 240         bool move = (event->pos() - m_clickEvent).manhattanLength() >= QApplication::startDragDistance();
 241         if (m_dragItem && m_tool == SELECTTOOL) {
 242             if (m_operationMode == MOVE && move) {
 243                 QGraphicsView::mouseMoveEvent(event);
 244                 // If mouse is at a border of the view, scroll
 245                 if (pos < 5) {
 246                     m_scrollOffset = -30;
 247                     m_scrollTimer.start();
 248                 } else if (viewport()->width() - pos < 10) {
 249                     m_scrollOffset = 30;
 250                     m_scrollTimer.start();
 251                 } else if (m_scrollTimer.isActive()) m_scrollTimer.stop();
 252
 253             } else if (m_operationMode == RESIZESTART && move) {
 254                 double snappedPos = getSnapPointForPos(mappedXPos);
 255                 m_dragItem->resizeStart((int)(snappedPos));
 256             } else if (m_operationMode == RESIZEEND && move) {
 257                 double snappedPos = getSnapPointForPos(mappedXPos);
 258                 m_dragItem->resizeEnd((int)(snappedPos));
 259             } else if (m_operationMode == FADEIN && move) {
 260                 ((ClipItem*) m_dragItem)->setFadeIn((int)(mappedXPos - m_dragItem->startPos().frames(m_document->fps())));
 261             } else if (m_operationMode == FADEOUT && move) {
 262                 ((ClipItem*) m_dragItem)->setFadeOut((int)(m_dragItem->endPos().frames(m_document->fps()) - mappedXPos));
 263             } else if (m_operationMode == KEYFRAME && move) {
 264                 GenTime keyFramePos = GenTime(mappedXPos, m_document->fps()) - m_dragItem->startPos() + m_dragItem->cropStart();
 265                 double pos = mapToScene(event->pos()).toPoint().y();
 266                 QRectF br = m_dragItem->sceneBoundingRect();
 267                 double maxh = 100.0 / br.height();
 268                 pos = (br.bottom() - pos) * maxh;
 269                 m_dragItem->updateKeyFramePos(keyFramePos, pos);
 270             }
 271
 272             if (m_animation) delete m_animation;
 273             m_animation = NULL;
 274             if (m_visualTip) delete m_visualTip;
 275             m_visualTip = NULL;
 276             return;
 277         } else if (m_operationMode == MOVEGUIDE) {
 278             if (m_animation) delete m_animation;
 279             m_animation = NULL;
 280             if (m_visualTip) delete m_visualTip;
 281             m_visualTip = NULL;
 282             QGraphicsView::mouseMoveEvent(event);
 283             return;
 284         } else if (m_operationMode == SPACER && move) {
 285             // spacer tool
 286             int mappedClick = (int)(mapToScene(m_clickEvent).x() + 0.5);
 287             m_selectionGroup->setPos(mappedXPos + (m_spacerStart - mappedClick) , m_selectionGroup->pos().y());
 288         }
 289     }
 290
 291     if (m_tool == RAZORTOOL) {
 292         setCursor(m_razorCursor);
 293         //QGraphicsView::mouseMoveEvent(event);
 294         //return;
 295     } else if (m_tool == SPACERTOOL) {
 296         setCursor(m_spacerCursor);
 297         return;
 298     }
 299
 300     QList<QGraphicsItem *> itemList = items(event->pos());
 301     QGraphicsRectItem *item = NULL;
 302     OPERATIONTYPE opMode = NONE;
 303
 304     if (itemList.count() == 1 && itemList.at(0)->type() == GUIDEITEM) {
 305         opMode = MOVEGUIDE;
 306     } else for (int i = 0; i < itemList.count(); i++) {
 307             if (itemList.at(i)->type() == AVWIDGET || itemList.at(i)->type() == TRANSITIONWIDGET) {
 308                 item = (QGraphicsRectItem*) itemList.at(i);
 309                 break;
 310             }
 311         }
 312
 313     if (item && event->buttons() == Qt::NoButton) {
 314         AbstractClipItem *clip = static_cast <AbstractClipItem*>(item);
 315         if (m_tool == RAZORTOOL) {
 316             // razor tool over a clip, display current frame in monitor
 317             if (!m_blockRefresh && item->type() == AVWIDGET) {
 318                 //TODO: solve crash when showing frame when moving razor over clip
 319                 //emit showClipFrame(((ClipItem *) item)->baseClip(), mapToScene(event->pos()).x() / m_scale - (clip->startPos() - clip->cropStart()).frames(m_document->fps()));
 320             }
 321             event->accept();
 322             return;
 323         }
 324         opMode = clip->operationMode(mapToScene(event->pos()));
 325         double size = 5;
 326         if (opMode == m_moveOpMode) {
 327             QGraphicsView::mouseMoveEvent(event);
 328             return;
 329         } else {
 330             if (m_visualTip) {
 331                 if (m_animation) delete m_animation;
 332                 m_animation = NULL;
 333                 m_animationTimer->stop();
 334                 delete m_visualTip;
 335                 m_visualTip = NULL;
 336             }
 337         }
 338         m_moveOpMode = opMode;
 339         if (opMode == MOVE) {
 340             setCursor(Qt::OpenHandCursor);
 341         } else if (opMode == RESIZESTART) {
 342             setCursor(KCursor("left_side", Qt::SizeHorCursor));
 343             if (m_visualTip == NULL) {
 344                 QRectF rect = clip->sceneBoundingRect();
 345                 QPolygon polygon;
 346                 polygon << QPoint(0, rect.height() / 2 - size * 2);
 347                 polygon << QPoint(size * 2, (int)(rect.height() / 2));
 348                 polygon << QPoint(0, (int)(rect.height() / 2 + size * 2));
 349                 polygon << QPoint(0, (int)(rect.height() / 2 - size * 2));
 350
 351                 m_visualTip = new QGraphicsPolygonItem(polygon);
 352                 ((QGraphicsPolygonItem*) m_visualTip)->setBrush(m_tipColor);
 353                 ((QGraphicsPolygonItem*) m_visualTip)->setPen(m_tipPen);
 354                 m_visualTip->setPos(rect.x(), rect.y());
 355                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 356                 m_visualTip->setZValue(100);
 357                 m_animation = new QGraphicsItemAnimation;
 358                 m_animation->setItem(m_visualTip);
 359                 m_animation->setTimeLine(m_animationTimer);
 360                 double scale = 2.0;
 361                 m_animation->setScaleAt(.5, scale, 1);
 362                 //m_animation->setPosAt(.5, QPointF(rect.x() - rect.x() * scale, 0));
 363                 scale = 1.0;
 364                 m_animation->setScaleAt(1, scale, 1);
 365                 //m_animation->setPosAt(1, QPointF(rect.x() - rect.x() * scale, 0));
 366                 scene()->addItem(m_visualTip);
 367                 m_animationTimer->start();
 368             }
 369         } else if (opMode == RESIZEEND) {
 370             setCursor(KCursor("right_side", Qt::SizeHorCursor));
 371             if (m_visualTip == NULL) {
 372                 QRectF rect = clip->sceneBoundingRect();
 373                 QPolygon polygon;
 374                 polygon << QPoint(0, (int)(rect.height() / 2 - size * 2));
 375                 polygon << QPoint(- size * 2, (int)(rect.height() / 2));
 376                 polygon << QPoint(0, (int)(rect.height() / 2 + size * 2));
 377                 polygon << QPoint(0, (int)(rect.height() / 2 - size * 2));
 378
 379                 m_visualTip = new QGraphicsPolygonItem(polygon);
 380                 ((QGraphicsPolygonItem*) m_visualTip)->setBrush(m_tipColor);
 381                 ((QGraphicsPolygonItem*) m_visualTip)->setPen(m_tipPen);
 382                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 383                 m_visualTip->setPos(rect.right(), rect.y());
 384                 m_visualTip->setZValue(100);
 385                 m_animation = new QGraphicsItemAnimation;
 386                 m_animation->setItem(m_visualTip);
 387                 m_animation->setTimeLine(m_animationTimer);
 388                 double scale = 2.0;
 389                 m_animation->setScaleAt(.5, scale, 1);
 390                 scale = 1.0;
 391                 m_animation->setScaleAt(1, scale, 1);
 392                 scene()->addItem(m_visualTip);
 393                 m_animationTimer->start();
 394             }
 395         } else if (opMode == FADEIN) {
 396             if (m_visualTip == NULL) {
 397                 ClipItem *item = (ClipItem *) clip;
 398                 QRectF rect = clip->sceneBoundingRect();
 399                 m_visualTip = new QGraphicsEllipseItem(-size, -size, size * 2, size * 2);
 400                 ((QGraphicsEllipseItem*) m_visualTip)->setBrush(m_tipColor);
 401                 ((QGraphicsEllipseItem*) m_visualTip)->setPen(m_tipPen);
 402                 m_visualTip->setPos(rect.x() + item->fadeIn(), rect.y());
 403                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 404                 m_visualTip->setZValue(100);
 405                 m_animation = new QGraphicsItemAnimation;
 406                 m_animation->setItem(m_visualTip);
 407                 m_animation->setTimeLine(m_animationTimer);
 408                 double scale = 2.0;
 409                 m_animation->setScaleAt(.5, scale, scale);
 410                 scale = 1.0;
 411                 m_animation->setScaleAt(1, scale, scale);
 412                 scene()->addItem(m_visualTip);
 413                 m_animationTimer->start();
 414             }
 415             setCursor(Qt::PointingHandCursor);
 416         } else if (opMode == FADEOUT) {
 417             if (m_visualTip == NULL) {
 418                 ClipItem *item = (ClipItem *) clip;
 419                 QRectF rect = clip->sceneBoundingRect();
 420                 m_visualTip = new QGraphicsEllipseItem(-size, -size, size * 2, size * 2);
 421                 ((QGraphicsEllipseItem*) m_visualTip)->setBrush(m_tipColor);
 422                 ((QGraphicsEllipseItem*) m_visualTip)->setPen(m_tipPen);
 423                 m_visualTip->setPos(rect.right() - item->fadeOut(), rect.y());
 424                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 425                 m_visualTip->setZValue(100);
 426                 m_animation = new QGraphicsItemAnimation;
 427                 m_animation->setItem(m_visualTip);
 428                 m_animation->setTimeLine(m_animationTimer);
 429                 double scale = 2.0;
 430                 m_animation->setScaleAt(.5, scale, scale);
 431                 scale = 1.0;
 432                 m_animation->setScaleAt(1, scale, scale);
 433                 scene()->addItem(m_visualTip);
 434                 m_animationTimer->start();
 435             }
 436             setCursor(Qt::PointingHandCursor);
 437         } else if (opMode == TRANSITIONSTART) {
 438             /*if (m_visualTip == NULL) {
 439                 QRectF rect = clip->sceneBoundingRect();
 440                 m_visualTip = new QGraphicsEllipseItem(-5, -5 , 10, 10);
 441                 ((QGraphicsEllipseItem*) m_visualTip)->setBrush(m_tipColor);
 442                 ((QGraphicsEllipseItem*) m_visualTip)->setPen(m_tipPen);
 443                 m_visualTip->setZValue(100);
 444                 m_animation = new QGraphicsItemAnimation;
 445                 m_animation->setItem(m_visualTip);
 446                 m_animation->setTimeLine(m_animationTimer);
 447                 m_visualTip->setPos(rect.x() + 10, rect.y() + rect.height() / 2 + 12);
 448                 double scale = 2.0;
 449                 m_animation->setScaleAt(.5, scale, scale);
 450                 scale = 1.0;
 451                 m_animation->setScaleAt(1, scale, scale);
 452                 scene()->addItem(m_visualTip);
 453                 m_animationTimer->start();
 454             }*/
 455             setCursor(Qt::PointingHandCursor);
 456         } else if (opMode == TRANSITIONEND) {
 457             /*if (m_visualTip == NULL) {
 458                 QRectF rect = clip->sceneBoundingRect();
 459                 m_visualTip = new QGraphicsEllipseItem(-5, -5 , 10, 10);
 460                 ((QGraphicsEllipseItem*) m_visualTip)->setBrush(m_tipColor);
 461                 ((QGraphicsEllipseItem*) m_visualTip)->setPen(m_tipPen);
 462                 m_visualTip->setZValue(100);
 463                 m_animation = new QGraphicsItemAnimation;
 464                 m_animation->setItem(m_visualTip);
 465                 m_animation->setTimeLine(m_animationTimer);
 466                 m_visualTip->setPos(rect.x() + rect.width() - 10 , rect.y() + rect.height() / 2 + 12);
 467                 double scale = 2.0;
 468                 m_animation->setScaleAt(.5, scale, scale);
 469                 scale = 1.0;
 470                 m_animation->setScaleAt(1, scale, scale);
 471                 scene()->addItem(m_visualTip);
 472                 m_animationTimer->start();
 473             }*/
 474             setCursor(Qt::PointingHandCursor);
 475         } else if (opMode == KEYFRAME) {
 476             setCursor(Qt::PointingHandCursor);
 477         }
 478     } // no clip under mouse
 479     else if (m_tool == RAZORTOOL) {
 480         event->accept();
 481         return;
 482     } else if (opMode == MOVEGUIDE) {
 483         m_moveOpMode = opMode;
 484         setCursor(Qt::SplitHCursor);
 485     } else {
 486         if (event->buttons() != Qt::NoButton && event->modifiers() == Qt::NoModifier) {
 487             m_moveOpMode = SEEK;
 488             setCursorPos(mappedXPos);
 489             slotCheckPositionScrolling();
 490         } else m_moveOpMode = NONE;
 491         if (m_visualTip) {
 492             if (m_animation) delete m_animation;
 493             m_animationTimer->stop();
 494             m_animation = NULL;
 495             delete m_visualTip;
 496             m_visualTip = NULL;
 497
 498         }
 499         setCursor(Qt::ArrowCursor);
 500     }
 501     QGraphicsView::mouseMoveEvent(event);
 502 }
 503
 504 // virtual
 505 void CustomTrackView::mousePressEvent(QMouseEvent * event) {
 506     m_menuPosition = QPoint();
 507     m_blockRefresh = true;
 508     bool collision = false;
 509
 510     if (m_tool != RAZORTOOL) activateMonitor();
 511     else if (m_document->renderer()->playSpeed() != 0.0) {
 512         m_document->renderer()->pause();
 513         return;
 514     }
 515     m_clickEvent = event->pos();
 516
 517     // special cases (middle click button or ctrl / shift click
 518     if (event->button() == Qt::MidButton) {
 519         m_document->renderer()->switchPlay();
 520         m_blockRefresh = false;
 521         m_operationMode = NONE;
 522         return;
 523     }
 524
 525     // check item under mouse
 526     QList<QGraphicsItem *> collisionList = items(event->pos());
 527
 528     if (event->modifiers() == Qt::ControlModifier && m_tool != SPACERTOOL && collisionList.count() == 0) {
 529         setDragMode(QGraphicsView::ScrollHandDrag);
 530         QGraphicsView::mousePressEvent(event);
 531         m_blockRefresh = false;
 532         m_operationMode = NONE;
 533         return;
 534     }
 535
 536     if (event->modifiers() == Qt::ShiftModifier && collisionList.count() == 0) {
 537         setDragMode(QGraphicsView::RubberBandDrag);
 538         QGraphicsView::mousePressEvent(event);
 539         m_blockRefresh = false;
 540         m_operationMode = RUBBERSELECTION;
 541         return;
 542     }
 543
 544     if (collisionList.count() == 1 && collisionList.at(0)->type() == GUIDEITEM) {
 545         // a guide item was pressed
 546         collisionList.at(0)->setFlag(QGraphicsItem::ItemIsMovable, true);
 547         m_dragItem = NULL;
 548         m_dragGuide = (Guide *) collisionList.at(0);
 549         collision = true;
 550         m_operationMode = MOVEGUIDE;
 551         // deselect all clips so that only the guide will move
 552         m_scene->clearSelection();
 553         resetSelectionGroup();
 554         updateSnapPoints(NULL);
 555         QGraphicsView::mousePressEvent(event);
 556         return;
 557     }
 558
 559     // Find first clip or transition under mouse
 560     int i = 0;
 561     m_dragItem = NULL;
 562     while (i < collisionList.count()) {
 563         if (collisionList.at(i)->type() == AVWIDGET || collisionList.at(i)->type() == TRANSITIONWIDGET) {
 564             m_dragItem = static_cast <AbstractClipItem *>(collisionList.at(i));
 565             m_dragItemInfo = m_dragItem->info();
 566             break;
 567         }
 568         i++;
 569     }
 570
 571     // context menu requested
 572     if (event->button() == Qt::RightButton) {
 573         if (m_dragItem) {
 574             if (!m_dragItem->isSelected()) {
 575                 resetSelectionGroup(false);
 576                 m_scene->clearSelection();
 577                 m_dragItem->setSelected(true);
 578             }
 579         }
 580         m_operationMode = NONE;
 581         displayContextMenu(event->globalPos(), m_dragItem);
 582         m_menuPosition = m_clickEvent;
 583         m_dragItem = NULL;
 584         event->accept();
 585         return;
 586     }
 587
 588     // No item under click
 589     if (m_dragItem == NULL || m_tool == SPACERTOOL) {
 590         resetSelectionGroup();
 591         setCursor(Qt::ArrowCursor);
 592         m_scene->clearSelection();
 593         event->accept();
 594         emit clipItemSelected(NULL);
 595         if (m_tool == SPACERTOOL) {
 596             QList<QGraphicsItem *> selection;
 597             if (event->modifiers() == Qt::ControlModifier) {
 598                 // Ctrl + click, select all items on track after click position
 599                 int track = (int)(mapToScene(m_clickEvent).y() / m_tracksHeight);
 600                 selection = items(m_clickEvent.x(), track * m_tracksHeight + 1, sceneRect().width() - m_clickEvent.x(), m_tracksHeight - 2);
 601             } else {
 602                 // Select all items on all tracks after click position
 603                 selection = items(event->pos().x(), 1, sceneRect().width() - event->pos().x(), sceneRect().height());
 604             }
 605             m_selectionGroup = new AbstractGroupItem(m_document->fps());
 606             scene()->addItem(m_selectionGroup);
 607             m_spacerStart = -1;
 608             int itemStart;
 609             for (int i = 0; i < selection.count(); i++) {
 610                 if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET) {
 611                     m_selectionGroup->addToGroup(selection.at(i));
 612                     selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
 613                     AbstractClipItem *item = static_cast <AbstractClipItem *>(selection.at(i));
 614                     itemStart = item->startPos().frames(m_document->fps());
 615                     if (m_spacerStart == -1 || itemStart < m_spacerStart)
 616                         m_spacerStart = itemStart;
 617                 }
 618             }
 619             QPointF top = m_selectionGroup->boundingRect().topLeft();
 620             m_selectionGroup->setPos(top);
 621             m_selectionGroup->translate(-top.x(), -top.y() + 1);
 622             m_operationMode = SPACER;
 623         } else setCursorPos((int)(mapToScene(event->x(), 0).x()));
 624         return;
 625     }
 626
 627     // Razor tool
 628     if (m_tool == RAZORTOOL) {
 629         if (m_dragItem->type() == TRANSITIONWIDGET) {
 630             emit displayMessage(i18n("Cannot cut a transition"), ErrorMessage);
 631             event->accept();
 632             m_dragItem = NULL;
 633             return;
 634         }
 635         AbstractClipItem *clip = static_cast <AbstractClipItem *>(m_dragItem);
 636         RazorClipCommand* command = new RazorClipCommand(this, clip->info(), GenTime((int)(mapToScene(event->pos()).x()), m_document->fps()), true);
 637         m_commandStack->push(command);
 638         m_document->setModified(true);
 639         m_dragItem = NULL;
 640         event->accept();
 641         return;
 642     }
 643     updateSnapPoints(m_dragItem);
 644     if (m_dragItem->type() == AVWIDGET) emit clipItemSelected((ClipItem*) m_dragItem);
 645     else emit clipItemSelected(NULL);
 646
 647     if (event->modifiers() != Qt::ControlModifier && (m_dragItem->group() || m_dragItem->isSelected())) {
 648         // If clicked item is selected, allow move
 649         event->accept();
 650         if (m_selectionGroup) m_selectionGroup->setSelected(true);
 651         if (m_operationMode == NONE) QGraphicsView::mousePressEvent(event);
 652     } else {
 653         resetSelectionGroup();
 654         if (event->modifiers() != Qt::ControlModifier) m_scene->clearSelection();
 655         m_dragItem->setSelected(!m_dragItem->isSelected());
 656         groupSelectedItems();
 657     }
 658
 659     m_clickPoint = QPoint((int)(mapToScene(event->pos()).x() - m_dragItem->startPos().frames(m_document->fps())), (int)(event->pos().y() - m_dragItem->pos().y()));
 660     /*
 661                         if (!item->isSelected()) {
 662
 663                             if (event->modifiers() != Qt::ControlModifier) {
 664                                 QList<QGraphicsItem *> itemList = items();
 665                                 for (int i = 0; i < itemList.count(); i++) {
 666                                     itemList.at(i)->setSelected(false);
 667                                     itemList.at(i)->update();
 668                                 }
 669                             }
 670                             item->setSelected(true);
 671                             item->update();
 672                         }
 673
 674
 675
 676                         m_clickPoint = QPoint((int)(mapToScene(event->pos()).x() - m_dragItem->startPos().frames(m_document->fps()) * m_scale), (int)(event->pos().y() - m_dragItem->pos().y()));
 677                         m_dragItemInfo.startPos = m_dragItem->startPos();
 678                         m_dragItemInfo.endPos = m_dragItem->endPos();
 679                         m_dragItemInfo.track = m_dragItem->track();
 680
 681                         m_selectedClipList.clear();
 682                         QList<QGraphicsItem *> selected = scene()->selectedItems();
 683                         for (int i = 0; i < selected.count(); i++) {
 684                             if (selected.at(i)->type() == AVWIDGET || selected.at(i)->type() == TRANSITIONWIDGET)
 685                                 m_selectedClipList.append(static_cast <AbstractClipItem *>(selected.at(i)));
 686                         }
 687           */
 688     m_operationMode = m_dragItem->operationMode(mapToScene(event->pos()));
 689
 690     if (m_operationMode == KEYFRAME) {
 691         m_dragItem->updateSelectedKeyFrame();
 692         m_blockRefresh = false;
 693         return;
 694     } else if (m_operationMode == MOVE) {
 695         setCursor(Qt::ClosedHandCursor);
 696     } else if (m_operationMode == TRANSITIONSTART) {
 697         ItemInfo info;
 698         info.startPos = m_dragItem->startPos();
 699         info.track = m_dragItem->track();
 700         int transitiontrack = getPreviousVideoTrack(info.track);
 701         ClipItem *transitionClip = NULL;
 702         if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.startPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
 703         if (transitionClip && transitionClip->endPos() < m_dragItem->endPos()) {
 704             info.endPos = transitionClip->endPos();
 705         } else info.endPos = info.startPos + GenTime(65, m_document->fps());
 706         if (info.endPos == info.startPos) info.endPos = info.startPos + GenTime(65, m_document->fps());
 707         slotAddTransition((ClipItem *) m_dragItem, info, transitiontrack);
 708     } else if (m_operationMode == TRANSITIONEND) {
 709         ItemInfo info;
 710         info.endPos = GenTime(m_dragItem->endPos().frames(m_document->fps()), m_document->fps());
 711         info.track = m_dragItem->track();
 712         int transitiontrack = getPreviousVideoTrack(info.track);
 713         ClipItem *transitionClip = NULL;
 714         if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.endPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
 715         if (transitionClip && transitionClip->startPos() > m_dragItem->startPos()) {
 716             info.startPos = transitionClip->startPos();
 717         } else info.startPos = info.endPos - GenTime(65, m_document->fps());
 718         if (info.endPos == info.startPos) info.startPos = info.endPos - GenTime(65, m_document->fps());
 719         QDomElement transition = MainWindow::transitions.getEffectByName("Luma").cloneNode().toElement();
 720         EffectsList::setParameter(transition, "reverse", "1");
 721         slotAddTransition((ClipItem *) m_dragItem, info, transitiontrack, transition);
 722     }
 723
 724     m_blockRefresh = false;
 725     //kDebug()<<pos;
 726     //QGraphicsView::mousePressEvent(event);
 727 }
 728
 729 void CustomTrackView::resetSelectionGroup(bool selectItems) {
 730     if (m_selectionGroup) {
 731         // delete selection group
 732         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
 733         for (int i = 0; i < children.count(); i++) {
 734             children.at(i)->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
 735             children.at(i)->setSelected(selectItems);
 736         }
 737         scene()->destroyItemGroup(m_selectionGroup);
 738         m_selectionGroup = NULL;
 739     }
 740 }
 741
 742 void CustomTrackView::groupSelectedItems() {
 743     if (m_selectionGroup) kDebug() << "///// ERROR, TRYING TO OVERRIDE EXISTING GROUP";
 744     QList<QGraphicsItem *> selection = m_scene->selectedItems();
 745     if (selection.count() > 1) {
 746         m_selectionGroup = new AbstractGroupItem(m_document->fps());
 747         scene()->addItem(m_selectionGroup);
 748         for (int i = 0; i < selection.count(); i++) {
 749             if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET) {
 750                 m_selectionGroup->addToGroup(selection.at(i));
 751                 selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
 752             }
 753         }
 754
 755         if (m_selectionGroup) {
 756             QPointF top = m_selectionGroup->boundingRect().topLeft();
 757             m_selectionGroup->setPos(top);
 758             m_selectionGroup->translate(-top.x(), -top.y() + 1);
 759             m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
 760             m_selectionGroupInfo.track = m_selectionGroup->track();
 761         }
 762     } else resetSelectionGroup();
 763 }
 764
 765 void CustomTrackView::mouseDoubleClickEvent(QMouseEvent *event) {
 766     kDebug() << "++++++++++++ DBL CLK";
 767     if (m_dragItem && m_dragItem->hasKeyFrames()) {
 768         if (m_moveOpMode == KEYFRAME) {
 769             // user double clicked on a keyframe, open edit dialog
 770             QDialog d(parentWidget());
 771             Ui::KeyFrameDialog_UI view;
 772             view.setupUi(&d);
 773             view.kfr_position->setText(m_document->timecode().getTimecode(GenTime(m_dragItem->selectedKeyFramePos(), m_document->fps()) - m_dragItem->cropStart(), m_document->fps()));
 774             view.kfr_value->setValue(m_dragItem->selectedKeyFrameValue());
 775             view.kfr_value->setFocus();
 776             if (d.exec() == QDialog::Accepted) {
 777                 int pos = m_document->timecode().getFrameCount(view.kfr_position->text(), m_document->fps());
 778                 m_dragItem->updateKeyFramePos(GenTime(pos, m_document->fps()) + m_dragItem->cropStart(), (double) view.kfr_value->value() * m_dragItem->keyFrameFactor());
 779                 ClipItem *item = (ClipItem *)m_dragItem;
 780                 QString previous = item->keyframes(item->selectedEffectIndex());
 781                 item->updateKeyframeEffect();
 782                 QString next = item->keyframes(item->selectedEffectIndex());
 783                 EditKeyFrameCommand *command = new EditKeyFrameCommand(this, item->track(), item->startPos(), item->selectedEffectIndex(), previous, next, false);
 784                 m_commandStack->push(command);
 785                 updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
 786             }
 787
 788         } else  {
 789             // add keyframe
 790             GenTime keyFramePos = GenTime((int)(mapToScene(event->pos()).x()), m_document->fps()) - m_dragItem->startPos() + m_dragItem->cropStart();
 791             m_dragItem->addKeyFrame(keyFramePos, mapToScene(event->pos()).toPoint().y());
 792             ClipItem * item = (ClipItem *) m_dragItem;
 793             QString previous = item->keyframes(item->selectedEffectIndex());
 794             item->updateKeyframeEffect();
 795             QString next = item->keyframes(item->selectedEffectIndex());
 796             EditKeyFrameCommand *command = new EditKeyFrameCommand(this, m_dragItem->track(), m_dragItem->startPos(), item->selectedEffectIndex(), previous, next, false);
 797             m_commandStack->push(command);
 798             updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
 799         }
 800     } else if (m_dragItem) {
 801         ClipDurationDialog d(m_dragItem, m_document->timecode(), this);
 802         if (d.exec() == QDialog::Accepted) {
 803             if (d.startPos() != m_dragItem->startPos()) {
 804                 if (m_dragItem->type() == AVWIDGET) {
 805                     ItemInfo startInfo;
 806                     startInfo.startPos = m_dragItem->startPos();
 807                     startInfo.endPos = m_dragItem->endPos();
 808                     startInfo.track = m_dragItem->track();
 809                     ItemInfo endInfo;
 810                     endInfo.startPos = d.startPos();
 811                     endInfo.endPos = m_dragItem->endPos() + (endInfo.startPos - startInfo.startPos);
 812                     endInfo.track = m_dragItem->track();
 813                     MoveClipCommand *command = new MoveClipCommand(this, startInfo, endInfo, true);
 814                     m_commandStack->push(command);
 815                 } else {
 816                     //TODO: move transition
 817                 }
 818             }
 819             if (d.duration() != m_dragItem->duration()) {
 820                 if (m_dragItem->type() == AVWIDGET) {
 821                     ItemInfo startInfo;
 822                     startInfo.startPos = m_dragItem->startPos();
 823                     startInfo.endPos = m_dragItem->endPos();
 824                     startInfo.track = m_dragItem->track();
 825                     ItemInfo endInfo;
 826                     endInfo.startPos = startInfo.startPos;
 827                     endInfo.endPos = endInfo.startPos + d.duration();
 828                     endInfo.track = m_dragItem->track();
 829                     ResizeClipCommand *command = new ResizeClipCommand(this, startInfo, endInfo, true);
 830                     m_commandStack->push(command);
 831                 } else {
 832                     //TODO: resize transition
 833                 }
 834             }
 835         }
 836     } else {
 837         QList<QGraphicsItem *> collisionList = items(event->pos());
 838         if (collisionList.count() == 1 && collisionList.at(0)->type() == GUIDEITEM) {
 839             Guide *editGuide = (Guide *) collisionList.at(0);
 840             if (editGuide) slotEditGuide(editGuide->info());
 841         }
 842     }
 843 }
 844
 845
 846 void CustomTrackView::editKeyFrame(const GenTime pos, const int track, const int index, const QString keyframes) {
 847     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()), track);
 848     if (clip) {
 849         clip->setKeyframes(index, keyframes);
 850         updateEffect(m_document->tracksCount() - clip->track(), clip->startPos(), clip->effectAt(index), index);
 851     } else emit displayMessage(i18n("Cannot find clip with keyframe"), ErrorMessage);
 852 }
 853
 854
 855 void CustomTrackView::displayContextMenu(QPoint pos, AbstractClipItem *clip) {
 856     if (clip == NULL) m_timelineContextMenu->popup(pos);
 857     else if (clip->type() == AVWIDGET) m_timelineContextClipMenu->popup(pos);
 858     else if (clip->type() == TRANSITIONWIDGET) m_timelineContextTransitionMenu->popup(pos);
 859 }
 860
 861 void CustomTrackView::activateMonitor() {
 862     emit activateDocumentMonitor();
 863 }
 864
 865 void CustomTrackView::dragEnterEvent(QDragEnterEvent * event) {
 866     if (event->mimeData()->hasFormat("kdenlive/clip")) {
 867         resetSelectionGroup();
 868
 869         QStringList list = QString(event->mimeData()->data("kdenlive/clip")).split(";");
 870         m_selectionGroup = new AbstractGroupItem(m_document->fps());
 871         QPoint pos = QPoint();
 872         DocClipBase *clip = m_document->getBaseClip(list.at(0));
 873         if (clip == NULL) kDebug() << " WARNING))))))))) CLIP NOT FOUND : " << list.at(0);
 874         ItemInfo info;
 875         info.startPos = GenTime(pos.x(), m_document->fps());
 876         info.cropStart = GenTime(list.at(1).toInt(), m_document->fps());
 877         info.endPos = info.startPos + GenTime(list.at(2).toInt() - list.at(1).toInt(), m_document->fps());
 878         info.track = (int)(pos.y() / m_tracksHeight);
 879         ClipItem *item = new ClipItem(clip, info, m_document->fps());
 880         m_selectionGroup->addToGroup(item);
 881         //TODO: check if we do not overlap another clip when first dropping in timeline
 882         // if (insertPossible(m_selectionGroup, event->pos()))
 883         scene()->addItem(m_selectionGroup);
 884         event->acceptProposedAction();
 885     } else if (event->mimeData()->hasFormat("kdenlive/producerslist")) {
 886         QStringList ids = QString(event->mimeData()->data("kdenlive/producerslist")).split(";");
 887         m_scene->clearSelection();
 888         resetSelectionGroup(false);
 889
 890         m_selectionGroup = new AbstractGroupItem(m_document->fps());
 891         QPoint pos = QPoint();
 892         for (int i = 0; i < ids.size(); ++i) {
 893             DocClipBase *clip = m_document->getBaseClip(ids.at(i));
 894             if (clip == NULL) kDebug() << " WARNING))))))))) CLIP NOT FOUND : " << ids.at(i);
 895             ItemInfo info;
 896             info.startPos = GenTime(pos.x(), m_document->fps());
 897             info.endPos = info.startPos + clip->duration();
 898             info.track = (int)(pos.y() / m_tracksHeight);
 899             ClipItem *item = new ClipItem(clip, info, m_document->fps());
 900             pos.setX(pos.x() + clip->duration().frames(m_document->fps()));
 901             m_selectionGroup->addToGroup(item);
 902         }
 903         //TODO: check if we do not overlap another clip when first dropping in timeline
 904         //if (insertPossible(m_selectionGroup, event->pos()))
 905         scene()->addItem(m_selectionGroup);
 906         event->acceptProposedAction();
 907     } else QGraphicsView::dragEnterEvent(event);
 908 }
 909
 910
 911 bool CustomTrackView::insertPossible(AbstractGroupItem *group, const QPoint &pos) const {
 912     QPolygonF path;
 913     QList<QGraphicsItem *> children = group->childItems();
 914     for (int i = 0; i < children.count(); i++) {
 915         if (children.at(i)->type() == AVWIDGET) {
 916             ClipItem *clip = static_cast <ClipItem *>(children.at(i));
 917             ItemInfo info = clip->info();
 918             kDebug() << " / / INSERT : " << pos.x();
 919             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);
 920             kDebug() << " / / INSERT RECT: " << shape;
 921             path = path.united(QPolygonF(shape));
 922         }
 923     }
 924
 925     QList<QGraphicsItem*> collindingItems = scene()->items(path, Qt::IntersectsItemShape);
 926     if (collindingItems.isEmpty()) return true;
 927     else {
 928         for (int i = 0; i < collindingItems.count(); i++) {
 929             QGraphicsItem *collision = collindingItems.at(i);
 930             if (collision->type() == AVWIDGET) {
 931                 // Collision
 932                 kDebug() << "// COLLISIION DETECTED";
 933                 return false;
 934             }
 935         }
 936         return true;
 937     }
 938
 939 }
 940
 941 void CustomTrackView::slotRefreshEffects(ClipItem *clip) {
 942     int track = m_document->tracksCount() - clip->track();
 943     GenTime pos = clip->startPos();
 944     if (!m_document->renderer()->mltRemoveEffect(track, pos, "-1", false)) {
 945         emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
 946         return;
 947     }
 948     bool success = true;
 949     for (int i = 0; i < clip->effectsCount(); i++) {
 950         if (!m_document->renderer()->mltAddEffect(track, pos, clip->getEffectArgs(clip->effectAt(i)), false)) success = false;
 951     }
 952     if (!success) emit displayMessage(i18n("Problem adding effect to clip"), ErrorMessage);
 953     m_document->renderer()->doRefresh();
 954 }
 955
 956 void CustomTrackView::addEffect(int track, GenTime pos, QDomElement effect) {
 957     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
 958     if (clip) {
 959         QHash <QString, QString> effectParams = clip->addEffect(effect);
 960         if (!m_document->renderer()->mltAddEffect(track, pos, effectParams))
 961             emit displayMessage(i18n("Problem adding effect to clip"), ErrorMessage);
 962         emit clipItemSelected(clip);
 963     } else emit displayMessage(i18n("Cannot find clip to add effect"), ErrorMessage);
 964 }
 965
 966 void CustomTrackView::deleteEffect(int track, GenTime pos, QDomElement effect) {
 967     QString index = effect.attribute("kdenlive_ix");
 968     if (effect.attribute("disabled") != "1" && !m_document->renderer()->mltRemoveEffect(track, pos, index)) {
 969         emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
 970         return;
 971     }
 972     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
 973     if (clip) {
 974         clip->deleteEffect(index);
 975         emit clipItemSelected(clip);
 976     }
 977 }
 978
 979 void CustomTrackView::slotAddEffect(QDomElement effect, GenTime pos, int track) {
 980     QList<QGraphicsItem *> itemList;
 981     if (track == -1) itemList = scene()->selectedItems();
 982     if (itemList.isEmpty()) {
 983         ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, track);
 984         if (clip) itemList.append(clip);
 985         else emit displayMessage(i18n("Select a clip if you want to apply an effect"), ErrorMessage);
 986     }
 987     kDebug() << "// REQUESTING EFFECT ON CLIP: " << pos.frames(25) << ", TRK: " << track << "SELECTED ITEMS: " << itemList.count();
 988     for (int i = 0; i < itemList.count(); i++) {
 989         if (itemList.at(i)->type() == AVWIDGET) {
 990             ClipItem *item = (ClipItem *)itemList.at(i);
 991             item->initEffect(effect);
 992             AddEffectCommand *command = new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), effect, true);
 993             m_commandStack->push(command);
 994         }
 995     }
 996     m_document->setModified(true);
 997 }
 998
 999 void CustomTrackView::slotDeleteEffect(ClipItem *clip, QDomElement effect) {
1000     AddEffectCommand *command = new AddEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), effect, false);
1001     m_commandStack->push(command);
1002     m_document->setModified(true);
1003 }
1004
1005 void CustomTrackView::updateEffect(int track, GenTime pos, QDomElement effect, int ix, bool triggeredByUser) {
1006     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1007     if (clip) {
1008         QHash <QString, QString> effectParams = clip->getEffectArgs(effect);
1009         // check if we are trying to reset a keyframe effect
1010         if (effectParams.contains("keyframes") && effectParams.value("keyframes").isEmpty()) {
1011             clip->initEffect(effect);
1012             clip->setEffectAt(ix, effect);
1013             effectParams = clip->getEffectArgs(effect);
1014         }
1015         if (effectParams.value("disabled") == "1") {
1016             if (m_document->renderer()->mltRemoveEffect(track, pos, effectParams.value("kdenlive_ix"))) {
1017                 kDebug() << "//////  DISABLING EFFECT: " << index << ", CURRENTLA: " << clip->selectedEffectIndex();
1018             } else emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
1019         } else if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - clip->track(), clip->startPos(), effectParams))
1020             emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
1021
1022         clip->setEffectAt(ix, effect);
1023         if (ix == clip->selectedEffectIndex()) {
1024             clip->setSelectedEffect(ix);
1025             if (!triggeredByUser) emit clipItemSelected(clip, ix);
1026         }
1027         if (effect.attribute("tag") == "volume") {
1028             // A fade effect was modified, update the clip
1029             if (effect.attribute("id") == "fadein") {
1030                 int pos = effectParams.value("out").toInt() - effectParams.value("in").toInt();
1031                 clip->setFadeIn(pos);
1032             }
1033             if (effect.attribute("id") == "fadeout") {
1034                 int pos = effectParams.value("out").toInt() - effectParams.value("in").toInt();
1035                 clip->setFadeOut(pos);
1036             }
1037
1038         }
1039     }
1040     m_document->setModified(true);
1041 }
1042
1043 void CustomTrackView::moveEffect(int track, GenTime pos, int oldPos, int newPos) {
1044     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1045     if (clip) {
1046         m_document->renderer()->mltMoveEffect(track, pos, oldPos, newPos);
1047         QDomElement act = clip->effectAt(newPos - 1).cloneNode().toElement();
1048         QDomElement before = clip->effectAt(oldPos - 1).cloneNode().toElement();
1049         clip->setEffectAt(oldPos - 1, act);
1050         clip->setEffectAt(newPos - 1, before);
1051         emit clipItemSelected(clip, newPos - 1);
1052     }
1053     m_document->setModified(true);
1054 }
1055
1056 void CustomTrackView::slotChangeEffectState(ClipItem *clip, int effectPos, bool disable) {
1057     QDomElement effect = clip->effectAt(effectPos);
1058     QDomElement oldEffect = effect.cloneNode().toElement();
1059     effect.setAttribute("disabled", disable);
1060     EditEffectCommand *command = new EditEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), oldEffect, effect, effectPos, true);
1061     m_commandStack->push(command);
1062     m_document->setModified(true);
1063 }
1064
1065 void CustomTrackView::slotChangeEffectPosition(ClipItem *clip, int currentPos, int newPos) {
1066     MoveEffectCommand *command = new MoveEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), currentPos, newPos, true);
1067     m_commandStack->push(command);
1068     m_document->setModified(true);
1069 }
1070
1071 void CustomTrackView::slotUpdateClipEffect(ClipItem *clip, QDomElement oldeffect, QDomElement effect, int ix) {
1072     EditEffectCommand *command = new EditEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), oldeffect, effect, ix, true);
1073     m_commandStack->push(command);
1074 }
1075
1076 void CustomTrackView::cutClip(ItemInfo info, GenTime cutTime, bool cut) {
1077     if (cut) {
1078         // cut clip
1079         ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
1080         if (!item || cutTime >= item->endPos() || cutTime <= item->startPos()) {
1081             emit displayMessage(i18n("Cannot find clip to cut"), ErrorMessage);
1082             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);
1083             m_blockRefresh = false;
1084             return;
1085         }
1086         kDebug() << "/////////  CUTTING CLIP : (" << item->startPos().frames(25) << "-" << item->endPos().frames(25) << "), INFO: (" << info.startPos.frames(25) << "-" << info.endPos.frames(25) << ")" << ", CUT: " << cutTime.frames(25);
1087
1088         m_document->renderer()->mltCutClip(m_document->tracksCount() - info.track, cutTime);
1089         int cutPos = (int) cutTime.frames(m_document->fps());
1090         ItemInfo newPos;
1091         newPos.startPos = cutTime;
1092         newPos.endPos = info.endPos;
1093         newPos.cropStart = item->cropStart() + (cutTime - info.startPos);
1094         newPos.track = info.track;
1095         ClipItem *dup = item->clone(newPos);
1096         kDebug() << "// REsizing item to: " << cutPos;
1097         item->resizeEnd(cutPos, false);
1098         scene()->addItem(dup);
1099         if (item->checkKeyFrames()) slotRefreshEffects(item);
1100         if (dup->checkKeyFrames()) slotRefreshEffects(dup);
1101         item->baseClip()->addReference();
1102         m_document->updateClip(item->baseClip()->getId());
1103         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);
1104         kDebug() << "//  CUTTING CLIP dONE";
1105     } else {
1106         // uncut clip
1107
1108         ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
1109         ClipItem *dup = getClipItemAt((int) cutTime.frames(m_document->fps()) + 1, info.track);
1110         if (!item || !dup || item == dup) {
1111             emit displayMessage(i18n("Cannot find clip to uncut"), ErrorMessage);
1112             m_blockRefresh = false;
1113             return;
1114         }
1115         if (m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, cutTime) == false) {
1116             emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(cutTime.frames(m_document->fps())), info.track), ErrorMessage);
1117             return;
1118         }
1119
1120         kDebug() << "// UNCUTTING CLIPS: ITEM 1 (" << item->startPos().frames(25) << "x" << item->endPos().frames(25) << ")";
1121         kDebug() << "// UNCUTTING CLIPS: ITEM 2 (" << dup->startPos().frames(25) << "x" << dup->endPos().frames(25) << ")";
1122         kDebug() << "// UNCUTTING CLIPS, INFO (" << info.startPos.frames(25) << "x" << info.endPos.frames(25) << ") , CUT: " << cutTime.frames(25);;
1123         //deleteClip(dup->info());
1124
1125
1126         if (dup->isSelected()) emit clipItemSelected(NULL);
1127         dup->baseClip()->removeReference();
1128         m_document->updateClip(dup->baseClip()->getId());
1129         scene()->removeItem(dup);
1130         delete dup;
1131
1132         ItemInfo clipinfo = item->info();
1133         clipinfo.track = m_document->tracksCount() - clipinfo.track;
1134         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, info.endPos - info.startPos);
1135         if (success) {
1136             item->resizeEnd((int) info.endPos.frames(m_document->fps()));
1137         } else
1138             emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
1139
1140     }
1141     QTimer::singleShot(3000, this, SLOT(slotEnableRefresh()));
1142 }
1143
1144 void CustomTrackView::slotEnableRefresh() {
1145     m_blockRefresh = false;
1146 }
1147
1148 void CustomTrackView::slotAddTransitionToSelectedClips(QDomElement transition) {
1149     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1150     if (itemList.count() == 1) {
1151         if (itemList.at(0)->type() == AVWIDGET) {
1152             ClipItem *item = (ClipItem *) itemList.at(0);
1153             ItemInfo info;
1154             info.track = item->track();
1155             ClipItem *transitionClip = NULL;
1156             const int transitiontrack = getPreviousVideoTrack(info.track);
1157             GenTime pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
1158             if (pos < item->startPos() + item->duration() / 2) {
1159                 // add transition to clip start
1160                 info.startPos = item->startPos();
1161                 if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.startPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
1162                 if (transitionClip && transitionClip->endPos() < item->endPos()) {
1163                     info.endPos = transitionClip->endPos();
1164                 } else info.endPos = info.startPos + GenTime(65, m_document->fps());
1165             } else {
1166                 // add transition to clip  end
1167                 info.endPos = item->endPos();
1168                 if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.endPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
1169                 if (transitionClip && transitionClip->startPos() > item->startPos()) {
1170                     info.startPos = transitionClip->startPos();
1171                 } else info.startPos = info.endPos - GenTime(65, m_document->fps());
1172                 if (transition.attribute("tag") == "luma") EffectsList::setParameter(transition, "reverse", "1");
1173             }
1174             slotAddTransition(item, info, transitiontrack, transition);
1175         }
1176     } else for (int i = 0; i < itemList.count(); i++) {
1177             if (itemList.at(i)->type() == AVWIDGET) {
1178                 ClipItem *item = (ClipItem *) itemList.at(i);
1179                 ItemInfo info;
1180                 info.startPos = item->startPos();
1181                 info.endPos = info.startPos + GenTime(65, m_document->fps());
1182                 info.track = item->track();
1183                 int transitiontrack = getPreviousVideoTrack(info.track);
1184                 slotAddTransition(item, info, transitiontrack, transition);
1185             }
1186         }
1187 }
1188
1189 void CustomTrackView::slotAddTransition(ClipItem* clip, ItemInfo transitionInfo, int endTrack, QDomElement transition) {
1190     AddTransitionCommand* command = new AddTransitionCommand(this, transitionInfo, endTrack, transition, false, true);
1191     m_commandStack->push(command);
1192     m_document->setModified(true);
1193 }
1194
1195 void CustomTrackView::addTransition(ItemInfo transitionInfo, int endTrack, QDomElement params) {
1196     Transition *tr = new Transition(transitionInfo, endTrack, m_document->fps(), params);
1197     scene()->addItem(tr);
1198
1199     //kDebug() << "---- ADDING transition " << params.attribute("value");
1200     m_document->renderer()->mltAddTransition(tr->transitionTag(), endTrack, m_document->tracksCount() - transitionInfo.track, transitionInfo.startPos, transitionInfo.endPos, tr->toXML());
1201     m_document->setModified(true);
1202 }
1203
1204 void CustomTrackView::deleteTransition(ItemInfo transitionInfo, int endTrack, QDomElement params) {
1205     Transition *item = getTransitionItemAt((int)transitionInfo.startPos.frames(m_document->fps()), transitionInfo.track);
1206     if (!item) {
1207         emit displayMessage(i18n("Select clip to delete"), ErrorMessage);
1208         return;
1209     }
1210     m_document->renderer()->mltDeleteTransition(item->transitionTag(), endTrack, m_document->tracksCount() - transitionInfo.track, transitionInfo.startPos, transitionInfo.endPos, item->toXML());
1211     if (m_dragItem == item) m_dragItem = NULL;
1212     delete item;
1213     emit transitionItemSelected(NULL);
1214     m_document->setModified(true);
1215 }
1216
1217 void CustomTrackView::slotTransitionUpdated(Transition *tr, QDomElement old) {
1218     EditTransitionCommand *command = new EditTransitionCommand(this, tr->track(), tr->startPos(), old, tr->toXML(), true);
1219     m_commandStack->push(command);
1220     m_document->setModified(true);
1221 }
1222
1223 void CustomTrackView::slotTransitionTrackUpdated(Transition *tr, int track) {
1224     QDomElement old = tr->toXML().cloneNode().toElement();
1225     if (track == 0) {
1226         track = getPreviousVideoTrack(tr->track());
1227         tr->setForcedTrack(false, track);
1228     } else {
1229         tr->setForcedTrack(true, m_document->tracksCount() + 1 - track);
1230     }
1231     EditTransitionCommand *command = new EditTransitionCommand(this, tr->track(), tr->startPos(), old, tr->toXML(), true);
1232     m_commandStack->push(command);
1233     m_document->setModified(true);
1234 }
1235
1236 void CustomTrackView::updateTransition(int track, GenTime pos, QDomElement oldTransition, QDomElement transition, bool updateTransitionWidget) {
1237     Transition *item = getTransitionItemAt((int)pos.frames(m_document->fps()), track);
1238     if (!item) {
1239         kWarning() << "Unable to find transition at pos :" << pos.frames(m_document->fps()) << ", ON track: " << track;
1240         return;
1241     }
1242     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);
1243     item->setTransitionParameters(transition);
1244     if (updateTransitionWidget) emit transitionItemSelected(item, true);
1245     m_document->setModified(true);
1246 }
1247
1248 void CustomTrackView::dragMoveEvent(QDragMoveEvent * event) {
1249     event->setDropAction(Qt::IgnoreAction);
1250     const int track = (int)(mapToScene(event->pos()).y() / m_tracksHeight);
1251     const int pos = mapToScene(event->pos()).x();
1252     //kDebug() << "// DRAG MOVE TO TRACK: " << track;
1253     if (m_selectionGroup) {
1254         m_selectionGroup->setPos(pos, event->pos().y());
1255         event->setDropAction(Qt::MoveAction);
1256         if (event->mimeData()->hasFormat("kdenlive/producerslist") || event->mimeData()->hasFormat("kdenlive/clip")) {
1257             event->acceptProposedAction();
1258         }
1259     } else {
1260         QGraphicsView::dragMoveEvent(event);
1261     }
1262 }
1263
1264 void CustomTrackView::dragLeaveEvent(QDragLeaveEvent * event) {
1265     if (m_selectionGroup) {
1266         QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1267         qDeleteAll(items);
1268         scene()->destroyItemGroup(m_selectionGroup);
1269         m_selectionGroup = NULL;
1270     } else QGraphicsView::dragLeaveEvent(event);
1271 }
1272
1273 void CustomTrackView::dropEvent(QDropEvent * event) {
1274     if (m_selectionGroup) {
1275         QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1276         resetSelectionGroup();
1277         m_scene->clearSelection();
1278         for (int i = 0; i < items.count(); i++) {
1279             ClipItem *item = static_cast <ClipItem *>(items.at(i));
1280             AddTimelineClipCommand *command = new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, false);
1281             m_commandStack->push(command);
1282             item->baseClip()->addReference();
1283             m_document->updateClip(item->baseClip()->getId());
1284             ItemInfo info;
1285             info = item->info();
1286             if (item->baseClip()->isTransparent()) {
1287                 // add transparency transition
1288                 int endTrack = getPreviousVideoTrack(info.track);
1289                 Transition *tr = new Transition(info, endTrack, m_document->fps(), MainWindow::transitions.getEffectByTag("composite", "alphatransparency"), true);
1290                 scene()->addItem(tr);
1291                 m_document->renderer()->mltAddTransition(tr->transitionTag(), endTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
1292             }
1293             info.track = m_document->tracksCount() - item->track();
1294             m_document->renderer()->mltInsertClip(info, item->xml(), item->baseClip()->producer(item->track()));
1295             item->setSelected(true);
1296         }
1297         m_document->setModified(true);
1298     } else QGraphicsView::dropEvent(event);
1299     setFocus();
1300 }
1301
1302
1303 QStringList CustomTrackView::mimeTypes() const {
1304     QStringList qstrList;
1305     // list of accepted mime types for drop
1306     qstrList.append("text/plain");
1307     qstrList.append("kdenlive/producerslist");
1308     qstrList.append("kdenlive/clip");
1309     return qstrList;
1310 }
1311
1312 Qt::DropActions CustomTrackView::supportedDropActions() const {
1313     // returns what actions are supported when dropping
1314     return Qt::MoveAction;
1315 }
1316
1317 void CustomTrackView::setDuration(int duration) {
1318     if (duration > sceneRect().width())
1319         setSceneRect(0, 0, (duration + 100), sceneRect().height());
1320     m_projectDuration = duration;
1321 }
1322
1323 int CustomTrackView::duration() const {
1324     return m_projectDuration;
1325 }
1326
1327 void CustomTrackView::addTrack(TrackInfo type, int ix) {
1328     if (ix == -1) m_document->insertTrack(ix, type);
1329     else {
1330         m_document->insertTrack(m_document->tracksCount() - ix, type);
1331         // insert track in MLT playlist
1332         m_document->renderer()->mltInsertTrack(m_document->tracksCount() - ix, type.type == VIDEOTRACK);
1333
1334         double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
1335         QRectF r(0, startY, sceneRect().width(), sceneRect().height() - startY);
1336         QList<QGraphicsItem *> selection = m_scene->items(r);
1337         resetSelectionGroup();
1338
1339         m_selectionGroup = new AbstractGroupItem(m_document->fps());
1340         scene()->addItem(m_selectionGroup);
1341         for (int i = 0; i < selection.count(); i++) {
1342             if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET)
1343                 m_selectionGroup->addToGroup(selection.at(i));
1344             selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
1345         }
1346         // Move graphic items
1347         m_selectionGroup->translate(0, m_tracksHeight);
1348
1349         // adjust track number
1350         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
1351         for (int i = 0; i < children.count(); i++) {
1352             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
1353             item->updateItem();
1354             ItemInfo clipinfo = item->info();
1355             if (item->type() == AVWIDGET) {
1356                 ClipItem *clip = static_cast <ClipItem *>(item);
1357                 // We add a move clip command so that we get the correct producer for new track number
1358                 if (clip->clipType() == AV || clip->clipType() == AUDIO) {
1359                     m_document->renderer()->mltUpdateClipProducer((int)(m_document->tracksCount() - clipinfo.track), clipinfo.startPos.frames(m_document->fps()), clip->baseClip()->producer(clipinfo.track));
1360                     kDebug() << "// UPDATING CLIP TO TRACK PROD: " << clipinfo.track;
1361                 }
1362             } else if (item->type() == TRANSITIONWIDGET) {
1363                 Transition *tr = static_cast <Transition *>(item);
1364                 int track = tr->transitionEndTrack();
1365                 if (track >= ix) {
1366                     tr->updateTransitionEndTrack(getPreviousVideoTrack(clipinfo.track));
1367                 }
1368             }
1369         }
1370         resetSelectionGroup(false);
1371
1372     }
1373     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), m_tracksHeight * m_document->tracksCount());
1374     setSceneRect(0, 0, sceneRect().width(), m_tracksHeight * m_document->tracksCount());
1375     verticalScrollBar()->setMaximum(m_tracksHeight * m_document->tracksCount());
1376     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
1377
1378     //setFixedHeight(50 * m_tracksCount);
1379 }
1380
1381 void CustomTrackView::removeTrack(int ix) {
1382     // Delete track in MLT playlist
1383     m_document->renderer()->mltDeleteTrack(m_document->tracksCount() - ix);
1384     m_document->deleteTrack(m_document->tracksCount() - ix - 1);
1385
1386     double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
1387     QRectF r(0, startY, sceneRect().width(), sceneRect().height() - startY);
1388     QList<QGraphicsItem *> selection = m_scene->items(r);
1389
1390     resetSelectionGroup();
1391
1392     m_selectionGroup = new AbstractGroupItem(m_document->fps());
1393     scene()->addItem(m_selectionGroup);
1394     for (int i = 0; i < selection.count(); i++) {
1395         if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET)
1396             m_selectionGroup->addToGroup(selection.at(i));
1397         selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
1398     }
1399     // Move graphic items
1400     qreal ydiff = 0 - (int) m_tracksHeight;
1401     m_selectionGroup->translate(0, ydiff);
1402
1403     // adjust track number
1404     QList<QGraphicsItem *> children = m_selectionGroup->childItems();
1405     //kDebug() << "// FOUND CLIPS TO MOVE: " << children.count();
1406     for (int i = 0; i < children.count(); i++) {
1407         if (children.at(i)->type() == AVWIDGET) {
1408             ClipItem *clip = static_cast <ClipItem *>(children.at(i));
1409             clip->updateItem();
1410             ItemInfo clipinfo = clip->info();
1411             kDebug() << "// CLIP TRK IS: " << clipinfo.track;
1412             // We add a move clip command so that we get the correct producer for new track number
1413             if (clip->clipType() == AV || clip->clipType() == AUDIO)
1414                 m_document->renderer()->mltUpdateClipProducer((int)(m_document->tracksCount() - clipinfo.track), clipinfo.startPos.frames(m_document->fps()), clip->baseClip()->producer(clipinfo.track));
1415         } else if (children.at(i)->type() == TRANSITIONWIDGET) {
1416             Transition *tr = static_cast <Transition *>(children.at(i));
1417             tr->updateItem();
1418             int track = tr->transitionEndTrack();
1419             if (track >= ix) {
1420                 ItemInfo clipinfo = tr->info();
1421                 tr->updateTransitionEndTrack(getPreviousVideoTrack(clipinfo.track));
1422             }
1423         }
1424     }
1425     resetSelectionGroup(false);
1426
1427     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), m_tracksHeight * m_document->tracksCount());
1428     setSceneRect(0, 0, sceneRect().width(), m_tracksHeight * m_document->tracksCount());
1429     verticalScrollBar()->setMaximum(m_tracksHeight * m_document->tracksCount());
1430     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
1431     viewport()->update();
1432 }
1433
1434 void CustomTrackView::changeTrack(int ix, TrackInfo type) {
1435     int tracknumber = m_document->tracksCount() - ix;
1436     m_document->setTrackType(tracknumber - 1, type);
1437     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
1438     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
1439     viewport()->update();
1440 }
1441
1442
1443 void CustomTrackView::slotSwitchTrackAudio(int ix) {
1444     /*for (int i = 0; i < m_document->tracksCount(); i++)
1445         kDebug() << "TRK " << i << " STATE: " << m_document->trackInfoAt(i).isMute << m_document->trackInfoAt(i).isBlind;*/
1446
1447     int tracknumber = m_document->tracksCount() - ix;
1448
1449     m_document->switchTrackAudio(tracknumber - 1, !m_document->trackInfoAt(tracknumber - 1).isMute);
1450     kDebug() << "NEXT TRK STATE: " << m_document->trackInfoAt(tracknumber - 1).isMute << m_document->trackInfoAt(tracknumber - 1).isBlind;
1451     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
1452     m_document->setModified(true);
1453 }
1454
1455 void CustomTrackView::slotSwitchTrackVideo(int ix) {
1456     int tracknumber = m_document->tracksCount() - ix;
1457     m_document->switchTrackVideo(tracknumber - 1, !m_document->trackInfoAt(tracknumber - 1).isBlind);
1458     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
1459     m_document->setModified(true);
1460 }
1461
1462 void CustomTrackView::slotRemoveSpace() {
1463     GenTime pos;
1464     int track = 0;
1465     if (m_menuPosition.isNull()) {
1466         pos = GenTime(cursorPos(), m_document->fps());
1467         bool ok;
1468         track = QInputDialog::getInteger(this, i18n("Remove Space"), i18n("Track"), 0, 0, m_document->tracksCount() - 1, 1, &ok);
1469         if (!ok) return;
1470     } else {
1471         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
1472         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight);
1473     }
1474     ClipItem *item = getClipItemAt(pos, track);
1475     if (item) {
1476         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);
1477         return;
1478     }
1479     int length = m_document->renderer()->mltGetSpaceLength(pos, m_document->tracksCount() - track);
1480     //kDebug() << "// GOT LENGT; " << length;
1481     if (length <= 0) {
1482         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);
1483         return;
1484     }
1485     InsertSpaceCommand *command = new InsertSpaceCommand(this, pos, track, GenTime(-length, m_document->fps()), true);
1486     m_commandStack->push(command);
1487 }
1488
1489 void CustomTrackView::slotInsertSpace() {
1490     GenTime pos;
1491     int track = 0;
1492     if (m_menuPosition.isNull()) {
1493         pos = GenTime(cursorPos(), m_document->fps());
1494     } else {
1495         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
1496         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight) + 1;
1497     }
1498     SpacerDialog d(GenTime(65, m_document->fps()), m_document->timecode(), track, m_document->tracksCount(), this);
1499     if (d.exec() != QDialog::Accepted) return;
1500     GenTime spaceDuration = d.selectedDuration();
1501     track = d.selectedTrack();
1502     ClipItem *item = getClipItemAt(pos, track);
1503     if (item) pos = item->startPos();
1504
1505     InsertSpaceCommand *command = new InsertSpaceCommand(this, pos, track, spaceDuration, true);
1506     m_commandStack->push(command);
1507 }
1508
1509 void CustomTrackView::insertSpace(const GenTime &pos, int track, const GenTime duration) {
1510     int diff = duration.frames(m_document->fps());
1511     QList<QGraphicsItem *> itemList;
1512     if (track == -1) itemList = scene()->items(pos.frames(m_document->fps()) , 1, sceneRect().width() - pos.frames(m_document->fps()), sceneRect().height());
1513     else itemList = scene()->items(pos.frames(m_document->fps()) , track * m_tracksHeight + 1, sceneRect().width() - pos.frames(m_document->fps()), m_tracksHeight - 2);
1514     resetSelectionGroup();
1515     m_selectionGroup = new AbstractGroupItem(m_document->fps());
1516     scene()->addItem(m_selectionGroup);
1517     for (int i = 0; i < itemList.count(); i++) {
1518         if (itemList.at(i)->type() == AVWIDGET || itemList.at(i)->type() == TRANSITIONWIDGET) {
1519             m_selectionGroup->addToGroup(itemList.at(i));
1520             itemList.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
1521         }
1522     }
1523
1524     m_selectionGroup->translate(diff, 0);
1525     resetSelectionGroup(false);
1526     if (track != -1) track = m_document->tracksCount() - track;
1527     m_document->renderer()->mltInsertSpace(pos, track, duration);
1528 }
1529
1530 void CustomTrackView::deleteClip(const QString &clipId) {
1531     QList<QGraphicsItem *> itemList = items();
1532     for (int i = 0; i < itemList.count(); i++) {
1533         if (itemList.at(i)->type() == AVWIDGET) {
1534             ClipItem *item = (ClipItem *)itemList.at(i);
1535             if (item->clipProducer() == clipId) {
1536                 AddTimelineClipCommand *command = new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true);
1537                 m_commandStack->push(command);
1538                 //delete item;
1539             }
1540         }
1541     }
1542 }
1543
1544 void CustomTrackView::setCursorPos(int pos, bool seek) {
1545     emit cursorMoved((int)(m_cursorPos), (int)(pos));
1546     m_cursorPos = pos;
1547     m_cursorLine->setPos(pos, 0);
1548     if (seek) m_document->renderer()->seek(GenTime(pos, m_document->fps()));
1549     else if (m_autoScroll) checkScrolling();
1550 }
1551
1552 void CustomTrackView::updateCursorPos() {
1553     m_cursorLine->setPos(m_cursorPos, 0);
1554 }
1555
1556 int CustomTrackView::cursorPos() {
1557     return (int)(m_cursorPos);
1558 }
1559
1560 void CustomTrackView::moveCursorPos(int delta) {
1561     if (m_cursorPos + delta < 0) delta = 0 - m_cursorPos;
1562     emit cursorMoved((int)(m_cursorPos), (int)((m_cursorPos + delta)));
1563     m_cursorPos += delta;
1564     m_cursorLine->setPos(m_cursorPos, 0);
1565     m_document->renderer()->seek(GenTime(m_cursorPos, m_document->fps()));
1566     //if (m_autoScroll && m_scale < 50) checkScrolling();
1567 }
1568
1569 void CustomTrackView::checkScrolling() {
1570     int vert = verticalScrollBar()->value();
1571     int hor = cursorPos();
1572     ensureVisible(hor, vert + 10, 2, 2, 50, 0);
1573     //centerOn(QPointF(cursorPos(), m_tracksHeight));
1574     /*QRect rectInView = viewport()->rect();
1575     int delta = rectInView.width() / 3;
1576     int max = rectInView.right() + horizontalScrollBar()->value() - delta;
1577     //kDebug() << "CURSOR POS: "<<m_cursorPos<< "Scale: "<<m_scale;
1578     if (m_cursorPos * m_scale >= max) horizontalScrollBar()->setValue((int)(horizontalScrollBar()->value() + 1 + m_scale));*/
1579 }
1580
1581 void CustomTrackView::mouseReleaseEvent(QMouseEvent * event) {
1582     kDebug() << "// MOUSE RELEASED, MODE: " << m_moveOpMode;
1583     if (m_moveOpMode == SEEK) m_moveOpMode = NONE;
1584     QGraphicsView::mouseReleaseEvent(event);
1585     if (m_scrollTimer.isActive()) m_scrollTimer.stop();
1586     if (event->button() == Qt::MidButton) {
1587         return;
1588     }
1589     setDragMode(QGraphicsView::NoDrag);
1590     if (m_operationMode == MOVEGUIDE) {
1591         setCursor(Qt::ArrowCursor);
1592         m_operationMode = NONE;
1593         m_dragGuide->setFlag(QGraphicsItem::ItemIsMovable, false);
1594         EditGuideCommand *command = new EditGuideCommand(this, m_dragGuide->position(), m_dragGuide->label(), GenTime(m_dragGuide->pos().x(), m_document->fps()), m_dragGuide->label(), false);
1595         m_commandStack->push(command);
1596         m_dragGuide->updateGuide(GenTime(m_dragGuide->pos().x(), m_document->fps()));
1597         m_dragGuide = NULL;
1598         m_dragItem = NULL;
1599         return;
1600     } else if (m_operationMode == SPACER) {
1601         int endClick = (int)(mapToScene(event->pos()).x() + 0.5);
1602         int mappedClick = (int)(mapToScene(m_clickEvent).x() + 0.5);
1603         int track = (int)(mapToScene(m_clickEvent).y() / m_tracksHeight);
1604         if (m_selectionGroup->sceneBoundingRect().height() > m_tracksHeight) {
1605             // We are moving all tracks
1606             track = -1;
1607         }
1608         ClipItem *item = getClipItemAt(mappedClick, track);
1609         if (item) mappedClick = item->startPos().frames(m_document->fps());
1610         int diff = m_selectionGroup->pos().x() - m_spacerStart;//endClick - mappedClick;
1611         kDebug() << "// MOVING SPACER DIFF:" << diff;
1612         if (diff < 0) mappedClick += diff;
1613         InsertSpaceCommand *command = new InsertSpaceCommand(this, GenTime(mappedClick, m_document->fps()), track, GenTime(diff, m_document->fps()), false);
1614         m_commandStack->push(command);
1615         if (track != -1) track = m_document->tracksCount() - track;
1616         m_document->renderer()->mltInsertSpace(GenTime(mappedClick, m_document->fps()), track, GenTime(diff, m_document->fps()));
1617         resetSelectionGroup(false);
1618         m_operationMode = NONE;
1619     } else if (m_operationMode == RUBBERSELECTION) {
1620         resetSelectionGroup();
1621         groupSelectedItems();
1622         m_operationMode = NONE;
1623     }
1624
1625     if (m_dragItem == NULL && m_selectionGroup == NULL) {
1626         emit transitionItemSelected(NULL);
1627         return;
1628     }
1629     ItemInfo info;
1630     if (m_dragItem) info = m_dragItem->info();
1631
1632     if (m_operationMode == MOVE) {
1633         setCursor(Qt::OpenHandCursor);
1634
1635         if (m_selectionGroup == NULL) {
1636             // we are moving one clip, easy
1637             if (m_dragItem->type() == AVWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
1638                 ClipItem *item = static_cast <ClipItem *>(m_dragItem);
1639                 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));
1640                 if (success) {
1641                     QUndoCommand *moveCommand = new QUndoCommand();
1642                     moveCommand->setText(i18n("Move clip"));
1643                     new MoveClipCommand(this, m_dragItemInfo, info, false, moveCommand);
1644                     // Also move automatic transition
1645                     Transition *tr = getTransitionItemAt((int) m_dragItemInfo.startPos.frames(m_document->fps()), m_dragItemInfo.track);
1646                     if (tr && tr->isAutomatic()) {
1647                         tr->updateTransitionEndTrack(getPreviousVideoTrack(info.track));
1648                         ItemInfo trInfo = tr->info();
1649                         ItemInfo newTrInfo = trInfo;
1650                         newTrInfo.startPos = m_dragItem->startPos();
1651                         kDebug() << "// CHECKING TRANS END TRACK ON: " << m_document->tracksCount() - tr->transitionEndTrack();
1652                         if (m_dragItemInfo.track == info.track && !getClipItemAtEnd(newTrInfo.endPos, m_document->tracksCount() - tr->transitionEndTrack()));
1653                         newTrInfo.endPos = newTrInfo.endPos + (newTrInfo.startPos - trInfo.startPos);
1654                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
1655                     }
1656                     m_commandStack->push(moveCommand);
1657                 } else {
1658                     // undo last move and emit error message
1659                     MoveClipCommand *command = new MoveClipCommand(this, info, m_dragItemInfo, true);
1660                     m_commandStack->push(command);
1661                     emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(m_dragItemInfo.startPos.frames(m_document->fps()))), ErrorMessage);
1662                 }
1663             }
1664             if (m_dragItem->type() == TRANSITIONWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
1665                 MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
1666                 m_commandStack->push(command);
1667                 Transition *transition = (Transition *) m_dragItem;
1668                 transition->updateTransitionEndTrack(getPreviousVideoTrack(m_dragItem->track()));
1669                 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);
1670             }
1671         } else {
1672             // Moving several clips. We need to delete them and readd them to new position,
1673             // or they might overlap each other during the move
1674
1675             QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1676
1677             QList<ItemInfo> clipsToMove = QList<ItemInfo> ();
1678             QList<ItemInfo> transitionsToMove = QList<ItemInfo> ();
1679
1680             GenTime timeOffset = GenTime(m_selectionGroup->scenePos().x(), m_document->fps()) - m_selectionGroupInfo.startPos;
1681             const int trackOffset = m_selectionGroup->track() - m_selectionGroupInfo.track;
1682             if (timeOffset != GenTime() || trackOffset != 0) {
1683                 QUndoCommand *moveClips = new QUndoCommand();
1684                 moveClips->setText(i18n("Move group"));
1685                 // remove items in MLT playlist
1686                 for (int i = 0; i < items.count(); i++) {
1687                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
1688                     ItemInfo info = item->info();
1689                     if (item->type() == AVWIDGET) {
1690                         if (m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
1691                             // error, clip cannot be removed from playlist
1692                             emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
1693                         } else {
1694                             clipsToMove.append(info);
1695                         }
1696                     } else {
1697                         transitionsToMove.append(info);
1698                         Transition *tr = static_cast <Transition*>(item);
1699                         m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
1700                     }
1701                 }
1702
1703                 for (int i = 0; i < items.count(); i++) {
1704                     // re-add items in correct place
1705                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
1706                     item->updateItem();
1707                     ItemInfo info = item->info();
1708                     if (item->type() == AVWIDGET) {
1709                         ClipItem *clip = static_cast <ClipItem*>(item);
1710                         info.track = m_document->tracksCount() - info.track;
1711                         m_document->renderer()->mltInsertClip(info, clip->xml(), clip->baseClip()->producer(info.track));
1712                     } else {
1713                         Transition *tr = static_cast <Transition*>(item);
1714                         int newTrack = tr->transitionEndTrack();
1715                         if (!tr->forcedTrack()) {
1716                             newTrack += trackOffset;
1717                             if (newTrack < 0 || newTrack > m_document->tracksCount()) newTrack = getPreviousVideoTrack(info.track);
1718                         }
1719                         tr->updateTransitionEndTrack(newTrack);
1720                         m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
1721                     }
1722                 }
1723
1724                 new MoveGroupCommand(this, clipsToMove, transitionsToMove, timeOffset, trackOffset, false, moveClips);
1725                 m_commandStack->push(moveClips);
1726
1727                 QPointF top = m_selectionGroup->sceneBoundingRect().topLeft();
1728                 //QPointF oldpos = m_selectionGroup->scenePos();
1729                 //kDebug()<<"SELECTION GRP POS: "<<m_selectionGroup->scenePos()<<", TOP: "<<top;
1730                 m_selectionGroup->setPos(top);
1731                 m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
1732                 m_selectionGroupInfo.track = m_selectionGroup->track();
1733             }
1734         }
1735
1736     } else if (m_operationMode == RESIZESTART && m_dragItem->startPos() != m_dragItemInfo.startPos) {
1737         // resize start
1738         if (m_dragItem->type() == AVWIDGET) {
1739             ItemInfo resizeinfo = m_dragItemInfo;
1740             resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
1741             bool success = m_document->renderer()->mltResizeClipStart(resizeinfo, m_dragItem->startPos() - m_dragItemInfo.startPos);
1742             if (success) {
1743                 QUndoCommand *resizeCommand = new QUndoCommand();
1744                 resizeCommand->setText(i18n("Resize clip"));
1745
1746                 // Check if there is an automatic transition on that clip
1747                 Transition *transition = getTransitionItemAt((int) m_dragItemInfo.startPos.frames(m_document->fps()), m_dragItemInfo.track);
1748                 if (transition && transition->isAutomatic() && transition->startPos() == m_dragItemInfo.startPos) {
1749                     ItemInfo trInfo = transition->info();
1750                     ItemInfo newTrInfo = trInfo;
1751                     newTrInfo.startPos = m_dragItem->startPos();
1752                     new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
1753                 }
1754                 updateClipFade(static_cast <ClipItem *>(m_dragItem));
1755                 new ResizeClipCommand(this, m_dragItemInfo, info, false, resizeCommand);
1756                 m_commandStack->push(resizeCommand);
1757             } else {
1758                 m_dragItem->resizeStart((int) m_dragItemInfo.startPos.frames(m_document->fps()));
1759                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
1760             }
1761         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
1762             MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
1763             m_commandStack->push(command);
1764             Transition *transition = static_cast <Transition *>(m_dragItem);
1765             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);
1766         }
1767
1768         //m_document->renderer()->doRefresh();
1769     } else if (m_operationMode == RESIZEEND && m_dragItem->endPos() != m_dragItemInfo.endPos) {
1770         // resize end
1771         if (m_dragItem->type() == AVWIDGET) {
1772             ItemInfo resizeinfo = info;
1773             resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
1774             bool success = m_document->renderer()->mltResizeClipEnd(resizeinfo, resizeinfo.endPos - resizeinfo.startPos);
1775             if (success) {
1776                 ResizeClipCommand *command = new ResizeClipCommand(this, m_dragItemInfo, info, false);
1777                 m_commandStack->push(command);
1778                 updateClipFade(static_cast <ClipItem *>(m_dragItem), true);
1779             } else {
1780                 m_dragItem->resizeEnd((int) m_dragItemInfo.endPos.frames(m_document->fps()));
1781                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
1782             }
1783         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
1784             MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
1785             m_commandStack->push(command);
1786             Transition *transition = static_cast <Transition *>(m_dragItem);
1787             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);
1788         }
1789         //m_document->renderer()->doRefresh();
1790     } else if (m_operationMode == FADEIN) {
1791         // resize fade in effect
1792         ClipItem * item = (ClipItem *) m_dragItem;
1793         int ix = item->hasEffect("volume", "fadein");
1794         if (ix != -1) {
1795             QDomElement oldeffect = item->effectAt(ix);
1796             int start = item->cropStart().frames(m_document->fps());
1797             int end = item->fadeIn();
1798             if (end == 0) {
1799                 slotDeleteEffect(item, oldeffect);
1800             } else {
1801                 end += start;
1802                 QDomElement effect = oldeffect.cloneNode().toElement();
1803                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
1804                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
1805                 slotUpdateClipEffect(item, effect, oldeffect, ix);
1806                 emit clipItemSelected(item, ix);
1807             }
1808         } else if (item->fadeIn() != 0) {
1809             QDomElement effect = MainWindow::audioEffects.getEffectByTag("volume", "fadein").cloneNode().toElement();
1810             EffectsList::setParameter(effect, "out", QString::number(item->fadeIn()));
1811             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
1812         }
1813     } else if (m_operationMode == FADEOUT) {
1814         // resize fade in effect
1815         ClipItem * item = (ClipItem *) m_dragItem;
1816         int ix = item->hasEffect("volume", "fadeout");
1817         if (ix != -1) {
1818             QDomElement oldeffect = item->effectAt(ix);
1819             int end = (item->duration() + item->cropStart()).frames(m_document->fps());
1820             int start = item->fadeOut();
1821             if (start == 0) {
1822                 slotDeleteEffect(item, oldeffect);
1823             } else {
1824                 start = end - start;
1825                 QDomElement effect = oldeffect.cloneNode().toElement();
1826                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
1827                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
1828                 slotUpdateClipEffect(item, effect, oldeffect, ix);
1829                 emit clipItemSelected(item, ix);
1830             }
1831         } else if (item->fadeOut() != 0) {
1832             QDomElement effect = MainWindow::audioEffects.getEffectByTag("volume", "fadeout").cloneNode().toElement();
1833             EffectsList::setParameter(effect, "out", QString::number(item->fadeOut()));
1834             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
1835         }
1836     } else if (m_operationMode == KEYFRAME) {
1837         // update the MLT effect
1838         ClipItem * item = (ClipItem *) m_dragItem;
1839         QString previous = item->keyframes(item->selectedEffectIndex());
1840         item->updateKeyframeEffect();
1841         QString next = item->keyframes(item->selectedEffectIndex());
1842         EditKeyFrameCommand *command = new EditKeyFrameCommand(this, item->track(), item->startPos(), item->selectedEffectIndex(), previous, next, false);
1843         m_commandStack->push(command);
1844         updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
1845     }
1846
1847     emit transitionItemSelected((m_dragItem && m_dragItem->type() == TRANSITIONWIDGET) ? static_cast <Transition *>(m_dragItem) : NULL);
1848     m_document->setModified(true);
1849     m_operationMode = NONE;
1850 }
1851
1852 void CustomTrackView::deleteClip(ItemInfo info) {
1853     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
1854
1855     if (!item || m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
1856         emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
1857         return;
1858     }
1859     if (item->isSelected()) emit clipItemSelected(NULL);
1860     item->baseClip()->removeReference();
1861     m_document->updateClip(item->baseClip()->getId());
1862
1863     if (item->baseClip()->isTransparent()) {
1864         // also remove automatic transition
1865         Transition *tr = getTransitionItemAt((int) info.startPos.frames(m_document->fps()), info.track);
1866         if (tr && tr->isAutomatic()) {
1867             m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
1868             scene()->removeItem(tr);
1869             delete tr;
1870         }
1871     }
1872     scene()->removeItem(item);
1873     if (m_dragItem == item) m_dragItem = NULL;
1874     delete item;
1875     m_document->renderer()->doRefresh();
1876 }
1877
1878 void CustomTrackView::deleteSelectedClips() {
1879     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1880     if (itemList.count() == 0) {
1881         emit displayMessage(i18n("Select clip to delete"), ErrorMessage);
1882         return;
1883     }
1884     QUndoCommand *deleteSelected = new QUndoCommand();
1885     deleteSelected->setText(i18n("Delete selected items"));
1886     for (int i = 0; i < itemList.count(); i++) {
1887         if (itemList.at(i)->type() == AVWIDGET) {
1888             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
1889             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true, deleteSelected);
1890         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
1891             Transition *item = static_cast <Transition *>(itemList.at(i));
1892             ItemInfo info;
1893             info.startPos = item->startPos();
1894             info.endPos = item->endPos();
1895             info.track = item->track();
1896             new AddTransitionCommand(this, info, item->transitionEndTrack(), item->toXML(), true, true, deleteSelected);
1897         }
1898     }
1899     m_commandStack->push(deleteSelected);
1900 }
1901
1902 void CustomTrackView::changeClipSpeed() {
1903     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1904     if (itemList.count() == 0) {
1905         emit displayMessage(i18n("Select clip to change speed"), ErrorMessage);
1906         return;
1907     }
1908     QUndoCommand *changeSelected = new QUndoCommand();
1909     changeSelected->setText("Edit clip speed");
1910     for (int i = 0; i < itemList.count(); i++) {
1911         if (itemList.at(i)->type() == AVWIDGET) {
1912             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
1913             ItemInfo info = item->info();
1914             int percent = QInputDialog::getInteger(this, i18n("Edit Clip Speed"), i18n("New speed (percents)"), item->speed() * 100, 1, 300);
1915             double speed = (double) percent / 100.0;
1916             if (item->speed() != speed)
1917                 new ChangeSpeedCommand(this, info, item->speed(), speed, item->clipProducer(), true, changeSelected);
1918         }
1919     }
1920     m_commandStack->push(changeSelected);
1921 }
1922
1923 void CustomTrackView::doChangeClipSpeed(ItemInfo info, const double speed, const double oldspeed, const QString &id) {
1924     DocClipBase *baseclip = m_document->clipManager()->getClipById(id);
1925     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
1926     info.track = m_document->tracksCount() - item->track();
1927     int endPos = m_document->renderer()->mltChangeClipSpeed(info, speed, oldspeed, baseclip->producer());
1928     //kDebug() << "//CH CLIP SPEED: " << speed << "x" << oldspeed << ", END POS: " << endPos;
1929     item->setSpeed(speed);
1930     item->updateRectGeometry();
1931     if (item->cropDuration().frames(m_document->fps()) > endPos)
1932         item->AbstractClipItem::resizeEnd(info.startPos.frames(m_document->fps()) + endPos, speed);
1933     m_document->setModified(true);
1934 }
1935
1936 void CustomTrackView::cutSelectedClips() {
1937     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1938     GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
1939     for (int i = 0; i < itemList.count(); i++) {
1940         if (itemList.at(i)->type() == AVWIDGET) {
1941             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
1942             if (currentPos > item->startPos() && currentPos <  item->endPos()) {
1943                 RazorClipCommand *command = new RazorClipCommand(this, item->info(), currentPos, true);
1944                 m_commandStack->push(command);
1945             }
1946         }
1947     }
1948 }
1949
1950 void CustomTrackView::addClip(QDomElement xml, const QString &clipId, ItemInfo info, EffectsList effects) {
1951     DocClipBase *baseclip = m_document->clipManager()->getClipById(clipId);
1952     if (baseclip == NULL) {
1953         emit displayMessage(i18n("No clip copied"), ErrorMessage);
1954         return;
1955     }
1956     ClipItem *item = new ClipItem(baseclip, info, m_document->fps());
1957     item->setEffectList(effects);
1958     scene()->addItem(item);
1959     if (item->baseClip()->isTransparent()) {
1960         // add transparency transition
1961         int endTrack = getPreviousVideoTrack(info.track);
1962         Transition *tr = new Transition(info, endTrack, m_document->fps(), MainWindow::transitions.getEffectByTag("composite", "alphatransparency"), true);
1963         scene()->addItem(tr);
1964         m_document->renderer()->mltAddTransition(tr->transitionTag(), endTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
1965     }
1966
1967     baseclip->addReference();
1968     m_document->updateClip(baseclip->getId());
1969     info.track = m_document->tracksCount() - info.track;
1970     m_document->renderer()->mltInsertClip(info, xml, baseclip->producer(info.track));
1971     for (int i = 0; i < item->effectsCount(); i++) {
1972         m_document->renderer()->mltAddEffect(info.track, info.startPos, item->getEffectArgs(item->effectAt(i)), false);
1973     }
1974     m_document->renderer()->doRefresh();
1975 }
1976
1977 void CustomTrackView::slotUpdateClip(const QString &clipId) {
1978     QList<QGraphicsItem *> list = scene()->items();
1979     ClipItem *clip = NULL;
1980     for (int i = 0; i < list.size(); ++i) {
1981         if (list.at(i)->type() == AVWIDGET) {
1982             clip = static_cast <ClipItem *>(list.at(i));
1983             if (clip->clipProducer() == clipId) {
1984                 clip->refreshClip();
1985                 ItemInfo info = clip->info();
1986                 info.track = m_document->tracksCount() - clip->track();
1987                 m_document->renderer()->mltUpdateClip(info, clip->xml(), clip->baseClip()->producer());
1988             }
1989         }
1990     }
1991 }
1992
1993 ClipItem *CustomTrackView::getClipItemAtEnd(GenTime pos, int track) {
1994     int framepos = (int)(pos.frames(m_document->fps()));
1995     QList<QGraphicsItem *> list = scene()->items(QPointF(framepos - 1, track * m_tracksHeight + m_tracksHeight / 2));
1996     ClipItem *clip = NULL;
1997     kDebug() << "// CHECK CLP  AT: " << framepos << ", TK: " << track << ", FND: " << list.size();
1998     for (int i = 0; i < list.size(); ++i) {
1999         if (list.at(i)->type() == AVWIDGET) {
2000             ClipItem *test = static_cast <ClipItem *>(list.at(i));
2001             kDebug() << "// GET END; " << test->endPos().frames(m_document->fps()) << " == " << framepos;
2002             if (test->endPos().frames(m_document->fps()) == framepos) clip = test;
2003             break;
2004         }
2005     }
2006     return clip;
2007 }
2008
2009 ClipItem *CustomTrackView::getClipItemAt(int pos, int track) {
2010     QList<QGraphicsItem *> list = scene()->items(QPointF(pos , track * m_tracksHeight + m_tracksHeight / 2));
2011     ClipItem *clip = NULL;
2012     for (int i = 0; i < list.size(); ++i) {
2013         if (list.at(i)->type() == AVWIDGET) {
2014             clip = static_cast <ClipItem *>(list.at(i));
2015             break;
2016         }
2017     }
2018     return clip;
2019 }
2020
2021 ClipItem *CustomTrackView::getClipItemAt(GenTime pos, int track) {
2022     int framepos = (int)(pos.frames(m_document->fps()));
2023     return getClipItemAt(framepos, track);
2024 }
2025
2026 Transition *CustomTrackView::getTransitionItemAt(int pos, int track) {
2027     QList<QGraphicsItem *> list = scene()->items(QPointF(pos, (track + 1) * m_tracksHeight));
2028     Transition *clip = NULL;
2029     for (int i = 0; i < list.size(); ++i) {
2030         if (list.at(i)->type() == TRANSITIONWIDGET) {
2031             clip = static_cast <Transition *>(list.at(i));
2032             break;
2033         }
2034     }
2035     return clip;
2036 }
2037
2038 Transition *CustomTrackView::getTransitionItemAt(GenTime pos, int track) {
2039     int framepos = (int)(pos.frames(m_document->fps()));
2040     return getTransitionItemAt(framepos, track);
2041 }
2042
2043 void CustomTrackView::moveClip(const ItemInfo start, const ItemInfo end) {
2044     if (m_selectionGroup) resetSelectionGroup(false);
2045     ClipItem *item = getClipItemAt((int) start.startPos.frames(m_document->fps()) + 1, start.track);
2046     if (!item) {
2047         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);
2048         kDebug() << "----------------  ERROR, CANNOT find clip to move at.. ";
2049         return;
2050     }
2051     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));
2052     if (success) {
2053         item->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
2054         m_scene->clearSelection();
2055         item->setSelected(true);
2056         if (item->baseClip()->isTransparent()) {
2057             // Also move automatic transition
2058             Transition *tr = getTransitionItemAt((int) start.startPos.frames(m_document->fps()), start.track);
2059             if (tr && tr->isAutomatic()) {
2060                 tr->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
2061                 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);
2062                 tr->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
2063             }
2064         }
2065     } else {
2066         // undo last move and emit error message
2067         emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(end.startPos.frames(m_document->fps()))), ErrorMessage);
2068     }
2069     kDebug() << " // MOVED CLIP TO: " << end.startPos.frames(25) << ", ITEM START: " << item->startPos().frames(25);
2070 }
2071
2072 void CustomTrackView::moveGroup(QList <ItemInfo> startClip, QList <ItemInfo> startTransition, const GenTime offset, const int trackOffset, bool reverseMove) {
2073     // Group Items
2074     kDebug() << "// GROUP MOVE; OFFSET: " << offset.frames(25) << ", TK OFF: " << trackOffset;
2075     resetSelectionGroup();
2076     m_scene->clearSelection();
2077     for (int i = 0; i < startClip.count(); i++) {
2078         if (reverseMove) {
2079             startClip[i].startPos = startClip.at(i).startPos - offset;
2080             startClip[i].track = startClip.at(i).track - trackOffset;
2081         }
2082         ClipItem *clip = getClipItemAt(startClip.at(i).startPos, startClip.at(i).track);
2083         if (clip) {
2084             clip->setSelected(true);
2085             m_document->renderer()->mltRemoveClip(m_document->tracksCount() - startClip.at(i).track, startClip.at(i).startPos);
2086         }
2087     }
2088     for (int i = 0; i < startTransition.count(); i++) {
2089         if (reverseMove) {
2090             startTransition[i].startPos = startTransition.at(i).startPos - offset;
2091             startTransition[i].track = startTransition.at(i).track - trackOffset;
2092         }
2093         Transition *tr = getTransitionItemAt(startTransition.at(i).startPos, startTransition.at(i).track);
2094         if (tr) {
2095             tr->setSelected(true);
2096             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());
2097         }
2098     }
2099     groupSelectedItems();
2100     if (m_selectionGroup) {
2101         QPointF pos = m_selectionGroup->pos();
2102         qreal posx = pos.x() + offset.frames(m_document->fps());
2103         qreal posy = pos.y() + trackOffset * (qreal) m_tracksHeight;
2104         m_selectionGroup->setPos(posx, posy);
2105
2106         QPointF top = m_selectionGroup->sceneBoundingRect().topLeft();
2107         m_selectionGroup->setPos(top);
2108         m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
2109         m_selectionGroupInfo.track = m_selectionGroup->track();
2110
2111         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
2112         for (int i = 0; i < children.count(); i++) {
2113             // re-add items in correct place
2114             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
2115             item->updateItem();
2116             ItemInfo info = item->info();
2117             if (item->type() == AVWIDGET) {
2118                 ClipItem *clip = static_cast <ClipItem*>(item);
2119                 info.track = m_document->tracksCount() - info.track;
2120                 m_document->renderer()->mltInsertClip(info, clip->xml(), clip->baseClip()->producer(info.track));
2121             } else {
2122                 Transition *tr = static_cast <Transition*>(item);
2123                 int newTrack = tr->transitionEndTrack();
2124                 kDebug() << "/// TRANSITION CURR TRK: " << newTrack;
2125                 if (!tr->forcedTrack()) {
2126                     newTrack += trackOffset;
2127                     if (newTrack < 0 || newTrack > m_document->tracksCount()) newTrack = getPreviousVideoTrack(info.track);
2128                 }
2129                 tr->updateTransitionEndTrack(newTrack);
2130                 kDebug() << "/// TRANSITION UPDATED TRK: " << newTrack;
2131                 m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2132             }
2133         }
2134     }
2135
2136 }
2137
2138 void CustomTrackView::moveTransition(const ItemInfo start, const ItemInfo end) {
2139     Transition *item = getTransitionItemAt((int)start.startPos.frames(m_document->fps()), start.track);
2140     if (!item) {
2141         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);
2142         kDebug() << "----------------  ERROR, CANNOT find transition to move... ";// << startPos.x() * m_scale * FRAME_SIZE + 1 << ", " << startPos.y() * m_tracksHeight + m_tracksHeight / 2;
2143         return;
2144     }
2145     //kDebug() << "----------------  Move TRANSITION FROM: " << startPos.x() << ", END:" << endPos.x() << ",TRACKS: " << oldtrack << " TO " << newtrack;
2146
2147     //kDebug()<<"///  RESIZE TRANS START: ("<< startPos.x()<<"x"<< startPos.y()<<") / ("<<endPos.x()<<"x"<< endPos.y()<<")";
2148     if (end.endPos - end.startPos == start.endPos - start.startPos) {
2149         // Transition was moved
2150         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
2151     } else if (end.endPos == start.endPos) {
2152         // Transition start resize
2153         item->resizeStart((int) end.startPos.frames(m_document->fps()));
2154     } else if (end.startPos == start.startPos) {
2155         // Transition end resize;
2156         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
2157     } else {
2158         // Move & resize
2159         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
2160         item->resizeStart((int) end.startPos.frames(m_document->fps()));
2161         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
2162     }
2163     //item->moveTransition(GenTime((int) (endPos.x() - startPos.x()), m_document->fps()));
2164     item->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
2165     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);
2166 }
2167
2168 void CustomTrackView::resizeClip(const ItemInfo start, const ItemInfo end) {
2169     int offset = 0;
2170     bool resizeClipStart = true;
2171     if (start.startPos == end.startPos) resizeClipStart = false;
2172     /*if (resizeClipStart) offset = 1;
2173     else offset = -1;*/
2174     ClipItem *item = getClipItemAt((int)(start.startPos.frames(m_document->fps()) + offset), start.track);
2175     if (!item) {
2176         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);
2177         kDebug() << "----------------  ERROR, CANNOT find clip to resize at... "; // << startPos;
2178         return;
2179     }
2180     if (resizeClipStart) {
2181         ItemInfo clipinfo = item->info();
2182         clipinfo.track = m_document->tracksCount() - clipinfo.track;
2183         bool success = m_document->renderer()->mltResizeClipStart(clipinfo, end.startPos - item->startPos());
2184         if (success) {
2185             item->resizeStart((int) end.startPos.frames(m_document->fps()));
2186             updateClipFade(item);
2187         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2188     } else {
2189         ItemInfo clipinfo = item->info();
2190         clipinfo.track = m_document->tracksCount() - clipinfo.track;
2191         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, end.endPos - clipinfo.startPos);
2192         if (success) {
2193             item->resizeEnd((int) end.endPos.frames(m_document->fps()));
2194             updateClipFade(item, true);
2195         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2196     }
2197     m_document->renderer()->doRefresh();
2198 }
2199
2200 void CustomTrackView::updateClipFade(ClipItem * item, bool updateFadeOut) {
2201     if (!updateFadeOut) {
2202         int end = item->fadeIn();
2203         if (end != 0) {
2204             // there is a fade in effect
2205             int effectPos = item->hasEffect("volume", "fadein");
2206             if (effectPos == -1) return;
2207             QDomElement oldeffect = item->effectAt(effectPos);
2208             int start = item->cropStart().frames(m_document->fps());
2209             int max = item->cropDuration().frames(m_document->fps());
2210             if (end > max) {
2211                 item->setFadeIn(max);
2212                 end = item->fadeIn();
2213             }
2214             end += start;
2215             EffectsList::setParameter(oldeffect, "in", QString::number(start));
2216             EffectsList::setParameter(oldeffect, "out", QString::number(end));
2217             QHash <QString, QString> effectParams = item->getEffectArgs(oldeffect);
2218             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), effectParams))
2219                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
2220             // if fade effect is displayed, update the effect edit widget with new clip duration
2221             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
2222         }
2223     } else {
2224         int start = item->fadeOut();
2225         if (start != 0) {
2226             // there is a fade in effect
2227             int effectPos = item->hasEffect("volume", "fadeout");
2228             if (effectPos == -1) return;
2229             QDomElement oldeffect = item->effectAt(effectPos);
2230             int end = (item->duration() - item->cropStart()).frames(m_document->fps());
2231             int max = item->cropDuration().frames(m_document->fps());
2232             if (end > max) {
2233                 item->setFadeOut(max);
2234                 start = item->fadeOut();
2235             }
2236             start = end - start;
2237             EffectsList::setParameter(oldeffect, "in", QString::number(start));
2238             EffectsList::setParameter(oldeffect, "out", QString::number(end));
2239             QHash <QString, QString> effectParams = item->getEffectArgs(oldeffect);
2240             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), effectParams))
2241                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
2242             // if fade effect is displayed, update the effect edit widget with new clip duration
2243             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
2244         }
2245     }
2246 }
2247
2248 double CustomTrackView::getSnapPointForPos(double pos) {
2249     return m_scene->getSnapPointForPos(pos, KdenliveSettings::snaptopoints());
2250 }
2251
2252 void CustomTrackView::updateSnapPoints(AbstractClipItem *selected) {
2253     QList <GenTime> snaps;
2254     GenTime offset;
2255     if (selected) offset = selected->duration();
2256     QList<QGraphicsItem *> itemList = items();
2257     for (int i = 0; i < itemList.count(); i++) {
2258         if (itemList.at(i)->type() == AVWIDGET && itemList.at(i) != selected) {
2259             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2260             GenTime start = item->startPos();
2261             GenTime end = item->endPos();
2262             snaps.append(start);
2263             snaps.append(end);
2264             QList < GenTime > markers = item->snapMarkers();
2265             for (int i = 0; i < markers.size(); ++i) {
2266                 GenTime t = markers.at(i);
2267                 snaps.append(t);
2268                 if (t > offset) snaps.append(t - offset);
2269             }
2270             if (offset != GenTime()) {
2271                 if (start > offset) snaps.append(start - offset);
2272                 if (end > offset) snaps.append(end - offset);
2273             }
2274         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
2275             Transition *transition = static_cast <Transition*>(itemList.at(i));
2276             GenTime start = transition->startPos();
2277             GenTime end = transition->endPos();
2278             snaps.append(start);
2279             snaps.append(end);
2280             if (offset != GenTime()) {
2281                 if (start > offset) snaps.append(start - offset);
2282                 if (end > offset) snaps.append(end - offset);
2283             }
2284         }
2285     }
2286
2287     // add cursor position
2288     GenTime pos = GenTime(m_cursorPos, m_document->fps());
2289     snaps.append(pos);
2290     if (offset != GenTime()) snaps.append(pos - offset);
2291
2292     // add guides
2293     for (int i = 0; i < m_guides.count(); i++) {
2294         snaps.append(m_guides.at(i)->position());
2295         if (offset != GenTime()) snaps.append(m_guides.at(i)->position() - offset);
2296     }
2297
2298     qSort(snaps);
2299     m_scene->setSnapList(snaps);
2300     //for (int i = 0; i < m_snapPoints.size(); ++i)
2301     //    kDebug() << "SNAP POINT: " << m_snapPoints.at(i).frames(25);
2302 }
2303
2304 void CustomTrackView::slotSeekToPreviousSnap() {
2305     updateSnapPoints(NULL);
2306     GenTime res = m_scene->previousSnapPoint(GenTime(m_cursorPos, m_document->fps()));
2307     setCursorPos((int) res.frames(m_document->fps()));
2308     checkScrolling();
2309 }
2310
2311 void CustomTrackView::slotSeekToNextSnap() {
2312     updateSnapPoints(NULL);
2313     GenTime res = m_scene->nextSnapPoint(GenTime(m_cursorPos, m_document->fps()));
2314     setCursorPos((int) res.frames(m_document->fps()));
2315     checkScrolling();
2316 }
2317
2318 void CustomTrackView::clipStart() {
2319     ClipItem *item = getMainActiveClip();
2320     if (item != NULL) {
2321         setCursorPos((int) item->startPos().frames(m_document->fps()));
2322         checkScrolling();
2323     }
2324 }
2325
2326 void CustomTrackView::clipEnd() {
2327     ClipItem *item = getMainActiveClip();
2328     if (item != NULL) {
2329         setCursorPos((int) item->endPos().frames(m_document->fps()));
2330         checkScrolling();
2331     }
2332 }
2333
2334 void CustomTrackView::slotAddClipMarker(const QString &id, GenTime t, QString c) {
2335     QString oldcomment = m_document->clipManager()->getClipById(id)->markerComment(t);
2336     AddMarkerCommand *command = new AddMarkerCommand(this, oldcomment, c, id, t, true);
2337     m_commandStack->push(command);
2338 }
2339
2340 void CustomTrackView::slotDeleteClipMarker(const QString &comment, const QString &id, const GenTime &position) {
2341     AddMarkerCommand *command = new AddMarkerCommand(this, comment, QString(), id, position, true);
2342     m_commandStack->push(command);
2343 }
2344
2345 void CustomTrackView::slotDeleteAllClipMarkers(const QString &id) {
2346     DocClipBase *base = m_document->clipManager()->getClipById(id);
2347     QList <CommentedTime> markers = base->commentedSnapMarkers();
2348
2349     if (markers.isEmpty()) {
2350         emit displayMessage(i18n("Clip has no markers"), ErrorMessage);
2351         return;
2352     }
2353     QUndoCommand *deleteMarkers = new QUndoCommand();
2354     deleteMarkers->setText("Delete clip markers");
2355
2356     for (int i = 0; i < markers.size(); i++) {
2357         new AddMarkerCommand(this, markers.at(i).comment(), QString(), id, markers.at(i).time(), true, deleteMarkers);
2358     }
2359     m_commandStack->push(deleteMarkers);
2360 }
2361
2362 void CustomTrackView::addMarker(const QString &id, const GenTime &pos, const QString comment) {
2363     DocClipBase *base = m_document->clipManager()->getClipById(id);
2364     if (!comment.isEmpty()) base->addSnapMarker(pos, comment);
2365     else base->deleteSnapMarker(pos);
2366     m_document->setModified(true);
2367     viewport()->update();
2368 }
2369
2370 bool sortGuidesList(const Guide *g1 , const Guide *g2) {
2371     return (*g1).position() < (*g2).position();
2372 }
2373
2374 void CustomTrackView::editGuide(const GenTime oldPos, const GenTime pos, const QString &comment) {
2375     if (oldPos > GenTime() && pos > GenTime()) {
2376         // move guide
2377         for (int i = 0; i < m_guides.count(); i++) {
2378             if (m_guides.at(i)->position() == oldPos) {
2379                 Guide *item = m_guides.at(i);
2380                 item->updateGuide(pos, comment);
2381                 break;
2382             }
2383         }
2384     } else if (pos > GenTime()) addGuide(pos, comment);
2385     else {
2386         // remove guide
2387         bool found = false;
2388         for (int i = 0; i < m_guides.count(); i++) {
2389             if (m_guides.at(i)->position() == oldPos) {
2390                 Guide *item = m_guides.takeAt(i);
2391                 delete item;
2392                 found = true;
2393                 break;
2394             }
2395         }
2396         if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
2397     }
2398     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
2399     m_document->syncGuides(m_guides);
2400 }
2401
2402 bool CustomTrackView::addGuide(const GenTime pos, const QString &comment) {
2403     for (int i = 0; i < m_guides.count(); i++) {
2404         if (m_guides.at(i)->position() == pos) {
2405             emit displayMessage(i18n("A guide already exists at position %1", m_document->timecode().getTimecodeFromFrames(pos.frames(m_document->fps()))), ErrorMessage);
2406             return false;
2407         }
2408     }
2409     Guide *g = new Guide(this, pos, comment, m_document->fps(), m_tracksHeight * m_document->tracksCount());
2410     scene()->addItem(g);
2411     m_guides.append(g);
2412     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
2413     m_document->syncGuides(m_guides);
2414     return true;
2415 }
2416
2417 void CustomTrackView::slotAddGuide() {
2418     CommentedTime marker(GenTime(m_cursorPos, m_document->fps()), i18n("Guide"));
2419     MarkerDialog d(NULL, marker, m_document->timecode(), i18n("Add Guide"), this);
2420     if (d.exec() != QDialog::Accepted) return;
2421     if (addGuide(d.newMarker().time(), d.newMarker().comment())) {
2422         EditGuideCommand *command = new EditGuideCommand(this, GenTime(), QString(), d.newMarker().time(), d.newMarker().comment(), false);
2423         m_commandStack->push(command);
2424     }
2425 }
2426
2427 void CustomTrackView::slotEditGuide() {
2428     GenTime pos = GenTime(m_cursorPos, m_document->fps());
2429     bool found = false;
2430     for (int i = 0; i < m_guides.count(); i++) {
2431         if (m_guides.at(i)->position() == pos) {
2432             slotEditGuide(m_guides.at(i)->info());
2433             found = true;
2434             break;
2435         }
2436     }
2437     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
2438 }
2439
2440 void CustomTrackView::slotEditGuide(CommentedTime guide) {
2441     MarkerDialog d(NULL, guide, m_document->timecode(), i18n("Edit Guide"), this);
2442     if (d.exec() == QDialog::Accepted) {
2443         EditGuideCommand *command = new EditGuideCommand(this, guide.time(), guide.comment(), d.newMarker().time(), d.newMarker().comment(), true);
2444         m_commandStack->push(command);
2445     }
2446 }
2447
2448
2449 void CustomTrackView::slotDeleteGuide() {
2450     GenTime pos = GenTime(m_cursorPos, m_document->fps());
2451     bool found = false;
2452     for (int i = 0; i < m_guides.count(); i++) {
2453         if (m_guides.at(i)->position() == pos) {
2454             EditGuideCommand *command = new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true);
2455             m_commandStack->push(command);
2456             found = true;
2457             break;
2458         }
2459     }
2460     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
2461 }
2462
2463 void CustomTrackView::slotDeleteAllGuides() {
2464     QUndoCommand *deleteAll = new QUndoCommand();
2465     deleteAll->setText("Delete all guides");
2466     for (int i = 0; i < m_guides.count(); i++) {
2467         EditGuideCommand *command = new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true, deleteAll);
2468     }
2469     m_commandStack->push(deleteAll);
2470 }
2471
2472 void CustomTrackView::setTool(PROJECTTOOL tool) {
2473     m_tool = tool;
2474 }
2475
2476 void CustomTrackView::setScale(double scaleFactor) {
2477     QMatrix matrix;
2478     matrix = matrix.scale(scaleFactor, 1);
2479     m_scene->setScale(scaleFactor);
2480     //scale(scaleFactor, 1);
2481     m_animationTimer->stop();
2482     if (m_visualTip) {
2483         delete m_visualTip;
2484         m_visualTip = NULL;
2485     }
2486     if (m_animation) {
2487         delete m_animation;
2488         m_animation = NULL;
2489     }
2490     /*double pos = cursorPos() / m_scale;
2491     m_scale = scaleFactor;
2492     m_scene->setScale(m_scale);
2493     int vert = verticalScrollBar()->value();
2494     kDebug() << " HHHHHHHH  SCALING: " << m_scale;
2495     QList<QGraphicsItem *> itemList = items();
2496     for (int i = 0; i < itemList.count(); i++) {
2497         if (itemList.at(i)->type() == AVWIDGET || itemList.at(i)->type() == TRANSITIONWIDGET) {
2498             AbstractClipItem *clip = (AbstractClipItem *)itemList.at(i);
2499             clip->setRect(0, 0, (qreal) clip->duration().frames(m_document->fps()) * m_scale - .5, clip->rect().height());
2500             clip->setPos((qreal) clip->startPos().frames(m_document->fps()) * m_scale, clip->pos().y());
2501         }
2502     }
2503
2504     for (int i = 0; i < m_guides.count(); i++) {
2505         m_guides.at(i)->updatePosition(m_scale);
2506     }
2507
2508     setSceneRect(0, 0, (m_projectDuration + 100) * m_scale, sceneRect().height());
2509     updateCursorPos();*/
2510     setMatrix(matrix);
2511     centerOn(QPointF(cursorPos(), m_tracksHeight));
2512     //verticalScrollBar()->setValue(vert);*/
2513 }
2514
2515 void CustomTrackView::slotRefreshGuides() {
2516     if (KdenliveSettings::showmarkers()) {
2517         kDebug() << "// refresh GUIDES";
2518         for (int i = 0; i < m_guides.count(); i++) {
2519             m_guides.at(i)->update();
2520         }
2521     }
2522 }
2523
2524 void CustomTrackView::drawBackground(QPainter * painter, const QRectF & rect) {
2525     QColor base = palette().button().color();
2526     QRectF r = rect;
2527     r.setWidth(r.width() + 1);
2528     painter->setClipRect(r);
2529     painter->drawLine(r.left(), 0, r.right(), 0);
2530     uint max = m_document->tracksCount();
2531     for (uint i = 0; i < max;i++) {
2532         /*if (max - i - 1 == m_selectedTrack) painter->fillRect(r.left(), m_tracksHeight * i + 1, r.right() - r.left() + 1, m_tracksHeight - 1, QBrush(QColor(211, 205, 147)));
2533                else*/
2534         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)));
2535         painter->drawLine(r.left(), m_tracksHeight * (i + 1), r.right(), m_tracksHeight * (i + 1));
2536     }
2537     int lowerLimit = m_tracksHeight * m_document->tracksCount() + 1;
2538     if (height() > lowerLimit)
2539         painter->fillRect(QRectF(r.left(), lowerLimit, r.width(), height() - lowerLimit), QBrush(base));
2540 }
2541
2542 bool CustomTrackView::findString(const QString &text) {
2543     QString marker;
2544     for (int i = 0; i < m_searchPoints.size(); ++i) {
2545         marker = m_searchPoints.at(i).comment();
2546         if (marker.contains(text, Qt::CaseInsensitive)) {
2547             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
2548             int vert = verticalScrollBar()->value();
2549             int hor = cursorPos();
2550             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
2551             m_findIndex = i;
2552             return true;
2553         }
2554     }
2555     return false;
2556 }
2557
2558 bool CustomTrackView::findNextString(const QString &text) {
2559     QString marker;
2560     for (int i = m_findIndex + 1; i < m_searchPoints.size(); ++i) {
2561         marker = m_searchPoints.at(i).comment();
2562         if (marker.contains(text, Qt::CaseInsensitive)) {
2563             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
2564             int vert = verticalScrollBar()->value();
2565             int hor = cursorPos();
2566             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
2567             m_findIndex = i;
2568             return true;
2569         }
2570     }
2571     m_findIndex = -1;
2572     return false;
2573 }
2574
2575 void CustomTrackView::initSearchStrings() {
2576     m_searchPoints.clear();
2577     QList<QGraphicsItem *> itemList = items();
2578     for (int i = 0; i < itemList.count(); i++) {
2579         // parse all clip names
2580         if (itemList.at(i)->type() == AVWIDGET) {
2581             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2582             GenTime start = item->startPos();
2583             CommentedTime t(start, item->clipName());
2584             m_searchPoints.append(t);
2585             // add all clip markers
2586             QList < CommentedTime > markers = item->commentedSnapMarkers();
2587             m_searchPoints += markers;
2588         }
2589     }
2590
2591     // add guides
2592     for (int i = 0; i < m_guides.count(); i++) {
2593         m_searchPoints.append(m_guides.at(i)->info());
2594     }
2595
2596     qSort(m_searchPoints);
2597 }
2598
2599 void CustomTrackView::clearSearchStrings() {
2600     m_searchPoints.clear();
2601     m_findIndex = 0;
2602 }
2603
2604 void CustomTrackView::copyClip() {
2605     while (m_copiedItems.count() > 0) {
2606         delete m_copiedItems.takeFirst();
2607     }
2608     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2609     if (itemList.count() == 0) {
2610         emit displayMessage(i18n("Select a clip before copying"), ErrorMessage);
2611         return;
2612     }
2613     for (int i = 0; i < itemList.count(); i++) {
2614         if (itemList.at(i)->type() == AVWIDGET) {
2615             ClipItem *dup = static_cast <ClipItem *>(itemList.at(i));
2616             m_copiedItems.append(dup->clone(dup->info()));
2617         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
2618             Transition *dup = static_cast <Transition *>(itemList.at(i));
2619             m_copiedItems.append(dup->clone());
2620         }
2621     }
2622 }
2623
2624 bool CustomTrackView::canBePastedTo(ItemInfo info, int type) const {
2625     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));
2626     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
2627     for (int i = 0; i < collisions.count(); i++) {
2628         if (collisions.at(i)->type() == type) return false;
2629     }
2630     return true;
2631 }
2632
2633 bool CustomTrackView::canBePasted(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const {
2634     for (int i = 0; i < items.count(); i++) {
2635         ItemInfo info = items.at(i)->info();
2636         info.startPos += offset;
2637         info.endPos += offset;
2638         info.track += trackOffset;
2639         if (!canBePastedTo(info, items.at(i)->type())) return false;
2640     }
2641     return true;
2642 }
2643
2644 bool CustomTrackView::canBeMoved(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const {
2645     QPainterPath movePath;
2646     movePath.moveTo(0, 0);
2647
2648     for (int i = 0; i < items.count(); i++) {
2649         ItemInfo info = items.at(i)->info();
2650         info.startPos = info.startPos + offset;
2651         info.endPos = info.endPos + offset;
2652         info.track = info.track + trackOffset;
2653         if (info.startPos < GenTime()) {
2654             // No clip should go below 0
2655             return false;
2656         }
2657         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));
2658         movePath.addRect(rect);
2659     }
2660     QList<QGraphicsItem *> collisions = scene()->items(movePath, Qt::IntersectsItemBoundingRect);
2661     for (int i = 0; i < collisions.count(); i++) {
2662         if ((collisions.at(i)->type() == AVWIDGET || collisions.at(i)->type() == TRANSITIONWIDGET) && !items.contains(static_cast <AbstractClipItem *>(collisions.at(i)))) {
2663             kDebug() << "  ////////////   CLIP COLLISION, MOVE NOT ALLOWED";
2664             return false;
2665         }
2666     }
2667     return true;
2668 }
2669
2670 void CustomTrackView::pasteClip() {
2671     if (m_copiedItems.count() == 0) {
2672         emit displayMessage(i18n("No clip copied"), ErrorMessage);
2673         return;
2674     }
2675     QPoint position;
2676     if (m_menuPosition.isNull()) position = mapFromGlobal(QCursor::pos());
2677     else position = m_menuPosition;
2678     GenTime pos = GenTime((int)(mapToScene(position).x()), m_document->fps());
2679     int track = (int)(position.y() / m_tracksHeight);
2680     ItemInfo first = m_copiedItems.at(0)->info();
2681
2682     GenTime offset = pos - first.startPos;
2683     int trackOffset = track - first.track;
2684
2685     if (!canBePasted(m_copiedItems, offset, trackOffset)) {
2686         emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
2687         return;
2688     }
2689     QUndoCommand *pasteClips = new QUndoCommand();
2690     pasteClips->setText("Paste clips");
2691
2692     for (int i = 0; i < m_copiedItems.count(); i++) {
2693         // parse all clip names
2694         if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == AVWIDGET) {
2695             ClipItem *clip = static_cast <ClipItem *>(m_copiedItems.at(i));
2696             ItemInfo info;
2697             info.startPos = clip->startPos() + offset;
2698             info.endPos = clip->endPos() + offset;
2699             info.cropStart = clip->cropStart();
2700             info.track = clip->track() + trackOffset;
2701             if (canBePastedTo(info, AVWIDGET)) {
2702                 new AddTimelineClipCommand(this, clip->xml(), clip->clipProducer(), info, clip->effectList(), true, false, pasteClips);
2703             } else emit displayMessage(i18n("Cannot paste clip to selected place"), ErrorMessage);
2704         } else if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == TRANSITIONWIDGET) {
2705             Transition *tr = static_cast <Transition *>(m_copiedItems.at(i));
2706             ItemInfo info;
2707             info.startPos = tr->startPos() + offset;
2708             info.endPos = tr->endPos() + offset;
2709             info.track = tr->track() + trackOffset;
2710             if (canBePastedTo(info, TRANSITIONWIDGET)) {
2711                 new AddTransitionCommand(this, info, tr->transitionEndTrack() + trackOffset, tr->toXML(), false, true, pasteClips);
2712             } else emit displayMessage(i18n("Cannot paste transition to selected place"), ErrorMessage);
2713         }
2714     }
2715     m_commandStack->push(pasteClips);
2716 }
2717
2718 void CustomTrackView::pasteClipEffects() {
2719     if (m_copiedItems.count() != 1 || m_copiedItems.at(0)->type() != AVWIDGET) {
2720         emit displayMessage(i18n("You must copy exactly one clip before pasting effects"), ErrorMessage);
2721         return;
2722     }
2723     ClipItem *clip = static_cast < ClipItem *>(m_copiedItems.at(0));
2724     EffectsList effects = clip->effectList();
2725
2726     QUndoCommand *paste = new QUndoCommand();
2727     paste->setText("Paste effects");
2728
2729     QList<QGraphicsItem *> clips = scene()->selectedItems();
2730     for (int i = 0; i < clips.count(); ++i) {
2731         if (clips.at(i)->type() == AVWIDGET) {
2732             ClipItem *item = static_cast < ClipItem *>(clips.at(i));
2733             for (int i = 0; i < clip->effectsCount(); i++) {
2734                 new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), clip->effectAt(i), true, paste);
2735             }
2736         }
2737     }
2738     m_commandStack->push(paste);
2739 }
2740
2741
2742 ClipItem *CustomTrackView::getClipUnderCursor() const {
2743     QRectF rect((double) m_cursorPos, 0.0, 1.0, (double)(m_tracksHeight * m_document->tracksCount()));
2744     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
2745     for (int i = 0; i < collisions.count(); i++) {
2746         if (collisions.at(i)->type() == AVWIDGET) {
2747             return static_cast < ClipItem *>(collisions.at(i));
2748         }
2749     }
2750     return NULL;
2751 }
2752
2753 ClipItem *CustomTrackView::getMainActiveClip() const {
2754     QList<QGraphicsItem *> clips = scene()->selectedItems();
2755     if (clips.isEmpty()) {
2756         return getClipUnderCursor();
2757     } else {
2758         ClipItem *item = NULL;
2759         for (int i = 0; i < clips.count(); ++i) {
2760             if (clips.at(i)->type() == AVWIDGET)
2761                 item = static_cast < ClipItem *>(clips.at(i));
2762             if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos) break;
2763         }
2764         if (item) return item;
2765     }
2766     return NULL;
2767 }
2768
2769 ClipItem *CustomTrackView::getActiveClipUnderCursor(bool allowOutsideCursor) const {
2770     QList<QGraphicsItem *> clips = scene()->selectedItems();
2771     if (clips.isEmpty()) {
2772         return getClipUnderCursor();
2773     } else {
2774         ClipItem *item;
2775         // remove all items in the list that are not clips
2776         for (int i = 0; i < clips.count();) {
2777             if (clips.at(i)->type() != AVWIDGET) clips.removeAt(i);
2778             else i++;
2779         }
2780         if (clips.count() == 1 && allowOutsideCursor) return static_cast < ClipItem *>(clips.at(0));
2781         for (int i = 0; i < clips.count(); ++i) {
2782             if (clips.at(i)->type() == AVWIDGET)
2783                 item = static_cast < ClipItem *>(clips.at(i));
2784             if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos) return item;
2785         }
2786     }
2787     return NULL;
2788 }
2789
2790 void CustomTrackView::setInPoint() {
2791     ClipItem *clip = getActiveClipUnderCursor(true);
2792     if (clip == NULL) {
2793         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
2794         return;
2795     }
2796     ItemInfo startInfo = clip->info();
2797     ItemInfo endInfo = clip->info();
2798     endInfo.startPos = GenTime(m_cursorPos, m_document->fps());
2799     ResizeClipCommand *command = new ResizeClipCommand(this, startInfo, endInfo, true);
2800     m_commandStack->push(command);
2801 }
2802
2803 void CustomTrackView::setOutPoint() {
2804     ClipItem *clip = getActiveClipUnderCursor(true);
2805     if (clip == NULL) {
2806         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
2807         return;
2808     }
2809     ItemInfo startInfo = clip->info();
2810     ItemInfo endInfo = clip->info();
2811     endInfo.endPos = GenTime(m_cursorPos, m_document->fps());
2812     ResizeClipCommand *command = new ResizeClipCommand(this, startInfo, endInfo, true);
2813     m_commandStack->push(command);
2814 }
2815
2816 void CustomTrackView::slotUpdateAllThumbs() {
2817     QList<QGraphicsItem *> itemList = items();
2818     //if (itemList.isEmpty()) return;
2819     ClipItem *item;
2820     QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
2821     for (int i = 0; i < itemList.count(); i++) {
2822         if (itemList.at(i)->type() == AVWIDGET) {
2823             item = static_cast <ClipItem *>(itemList.at(i));
2824             if (item->clipType() != COLOR) {
2825                 // Check if we have a cached thumbnail
2826                 if (item->clipType() == IMAGE || item->clipType() == TEXT || item->clipType() == AUDIO) {
2827                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
2828                     if (QFile::exists(thumb)) {
2829                         QPixmap pix(thumb);
2830                         item->slotSetStartThumb(pix);
2831                         item->slotSetEndThumb(pix);
2832                     }
2833                 } else {
2834                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
2835                     QString endThumb = startThumb;
2836                     startThumb.append(QString::number(item->cropStart().frames(m_document->fps())) + ".png");
2837                     endThumb.append(QString::number((item->cropStart() + item->cropDuration()).frames(m_document->fps()) - 1) + ".png");
2838                     if (QFile::exists(startThumb)) {
2839                         QPixmap pix(startThumb);
2840                         item->slotSetStartThumb(pix);
2841                     }
2842                     if (QFile::exists(endThumb)) {
2843                         QPixmap pix(endThumb);
2844                         item->slotSetEndThumb(pix);
2845                     }
2846                 }
2847             }
2848             item->refreshClip();
2849             qApp->processEvents();
2850         }
2851     }
2852     viewport()->update();
2853 }
2854
2855 void CustomTrackView::saveThumbnails() {
2856     QList<QGraphicsItem *> itemList = items();
2857     ClipItem *item;
2858     QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
2859     for (int i = 0; i < itemList.count(); i++) {
2860         if (itemList.at(i)->type() == AVWIDGET) {
2861             item = static_cast <ClipItem *>(itemList.at(i));
2862             if (item->clipType() != COLOR) {
2863                 // Check if we have a cached thumbnail
2864                 if (item->clipType() == IMAGE || item->clipType() == TEXT || item->clipType() == AUDIO) {
2865                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
2866                     if (!QFile::exists(thumb)) {
2867                         QPixmap pix(item->startThumb());
2868                         pix.save(thumb);
2869                     }
2870                 } else {
2871                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
2872                     QString endThumb = startThumb;
2873                     startThumb.append(QString::number(item->cropStart().frames(m_document->fps())) + ".png");
2874                     endThumb.append(QString::number((item->cropStart() + item->cropDuration()).frames(m_document->fps()) - 1) + ".png");
2875                     if (!QFile::exists(startThumb)) {
2876                         QPixmap pix(item->startThumb());
2877                         pix.save(startThumb);
2878                     }
2879                     if (!QFile::exists(endThumb)) {
2880                         QPixmap pix(item->endThumb());
2881                         pix.save(endThumb);
2882                     }
2883                 }
2884             }
2885         }
2886     }
2887 }
2888
2889
2890 void CustomTrackView::slotInsertTrack(int ix) {
2891     kDebug() << "// INSERTING TRK: " << ix;
2892     QDialog d(parentWidget());
2893     Ui::AddTrack_UI view;
2894     view.setupUi(&d);
2895     view.track_nb->setMaximum(m_document->tracksCount() - 1);
2896     view.track_nb->setValue(ix);
2897     d.setWindowTitle(i18n("Insert Track"));
2898
2899     if (d.exec() == QDialog::Accepted) {
2900         if (view.before_select->currentIndex() == 1) {
2901             ix++;
2902         }
2903         TrackInfo info;
2904         if (view.video_track->isChecked()) {
2905             info.type = VIDEOTRACK;
2906             info.isMute = false;
2907             info.isBlind = false;
2908         } else {
2909             info.type = AUDIOTRACK;
2910             info.isMute = false;
2911             info.isBlind = true;
2912         }
2913         AddTrackCommand *addTrack = new AddTrackCommand(this, ix, info, true, true);
2914         m_commandStack->push(addTrack);
2915         m_document->setModified(true);
2916     }
2917 }
2918
2919 void CustomTrackView::slotDeleteTrack(int ix) {
2920     bool ok;
2921     ix = QInputDialog::getInteger(this, i18n("Remove Track"), i18n("Track"), ix, 0, m_document->tracksCount() - 1, 1, &ok);
2922     if (ok) {
2923         TrackInfo info = m_document->trackInfoAt(m_document->tracksCount() - ix - 1);
2924         deleteTimelineTrack(ix, info);
2925         m_document->setModified(true);
2926         /*AddTrackCommand* command = new AddTrackCommand(this, ix, info, false, true);
2927         m_commandStack->push(command);*/
2928     }
2929 }
2930
2931 void CustomTrackView::slotChangeTrack(int ix) {
2932     QDialog d(parentWidget());
2933     Ui::AddTrack_UI view;
2934     view.setupUi(&d);
2935     view.label->setText(i18n("Change track"));
2936     view.before_select->setHidden(true);
2937     view.track_nb->setMaximum(m_document->tracksCount() - 1);
2938     view.track_nb->setValue(ix);
2939     d.setWindowTitle(i18n("Change Track Type"));
2940
2941     if (d.exec() == QDialog::Accepted) {
2942         TrackInfo info;
2943         if (view.video_track->isChecked()) {
2944             info.type = VIDEOTRACK;
2945             info.isMute = false;
2946             info.isBlind = false;
2947         } else {
2948             info.type = AUDIOTRACK;
2949             info.isMute = false;
2950             info.isBlind = true;
2951         }
2952         changeTimelineTrack(ix, info);
2953         m_document->setModified(true);
2954     }
2955 }
2956
2957
2958 void CustomTrackView::deleteTimelineTrack(int ix, TrackInfo trackinfo) {
2959     double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
2960     QRectF r(0, startY, sceneRect().width(), m_tracksHeight / 2 - 1);
2961     QList<QGraphicsItem *> selection = m_scene->items(r);
2962     QUndoCommand *deleteTrack = new QUndoCommand();
2963     deleteTrack->setText("Delete track");
2964
2965     // Delete all clips in selected track
2966     for (int i = 0; i < selection.count(); i++) {
2967         if (selection.at(i)->type() == AVWIDGET) {
2968             ClipItem *item =  static_cast <ClipItem *>(selection.at(i));
2969             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, true, deleteTrack);
2970             m_scene->removeItem(item);
2971             delete item;
2972             item = NULL;
2973         } else if (selection.at(i)->type() == TRANSITIONWIDGET) {
2974             Transition *item =  static_cast <Transition *>(selection.at(i));
2975             new AddTransitionCommand(this, item->info(), item->transitionEndTrack(), item->toXML(), true, false, deleteTrack);
2976             m_scene->removeItem(item);
2977             delete item;
2978             item = NULL;
2979         }
2980     }
2981
2982     new AddTrackCommand(this, ix, trackinfo, false, true, deleteTrack);
2983     m_commandStack->push(deleteTrack);
2984 }
2985
2986 void CustomTrackView::changeTimelineTrack(int ix, TrackInfo trackinfo) {
2987     TrackInfo oldinfo = m_document->trackInfoAt(m_document->tracksCount() - ix);
2988     ChangeTrackCommand *changeTrack = new ChangeTrackCommand(this, ix, oldinfo, trackinfo, true);
2989     m_commandStack->push(changeTrack);
2990 }
2991
2992 void CustomTrackView::autoTransition() {
2993     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2994     if (itemList.count() != 1 || itemList.at(0)->type() != TRANSITIONWIDGET) {
2995         emit displayMessage(i18n("You must select one transition for this action"), ErrorMessage);
2996         return;
2997     }
2998     Transition *tr = static_cast <Transition*>(itemList.at(0));
2999     tr->setAutomatic(!tr->isAutomatic());
3000     QDomElement transition = tr->toXML();
3001     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);
3002 }
3003
3004 #include "customtrackview.moc"