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     //setFixedHeight(50 * m_tracksCount);
1378 }
1379
1380 void CustomTrackView::removeTrack(int ix) {
1381     // Delete track in MLT playlist
1382     m_document->renderer()->mltDeleteTrack(m_document->tracksCount() - ix);
1383     m_document->deleteTrack(m_document->tracksCount() - ix - 1);
1384
1385     double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
1386     QRectF r(0, startY, sceneRect().width(), sceneRect().height() - startY);
1387     QList<QGraphicsItem *> selection = m_scene->items(r);
1388
1389     resetSelectionGroup();
1390
1391     m_selectionGroup = new AbstractGroupItem(m_document->fps());
1392     scene()->addItem(m_selectionGroup);
1393     for (int i = 0; i < selection.count(); i++) {
1394         if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET)
1395             m_selectionGroup->addToGroup(selection.at(i));
1396         selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
1397     }
1398     // Move graphic items
1399     qreal ydiff = 0 - (int) m_tracksHeight;
1400     m_selectionGroup->translate(0, ydiff);
1401
1402     // adjust track number
1403     QList<QGraphicsItem *> children = m_selectionGroup->childItems();
1404     //kDebug() << "// FOUND CLIPS TO MOVE: " << children.count();
1405     for (int i = 0; i < children.count(); i++) {
1406         if (children.at(i)->type() == AVWIDGET) {
1407             ClipItem *clip = static_cast <ClipItem *>(children.at(i));
1408             clip->updateItem();
1409             ItemInfo clipinfo = clip->info();
1410             kDebug() << "// CLIP TRK IS: " << clipinfo.track;
1411             // We add a move clip command so that we get the correct producer for new track number
1412             if (clip->clipType() == AV || clip->clipType() == AUDIO)
1413                 m_document->renderer()->mltUpdateClipProducer((int)(m_document->tracksCount() - clipinfo.track), clipinfo.startPos.frames(m_document->fps()), clip->baseClip()->producer(clipinfo.track));
1414         } else if (children.at(i)->type() == TRANSITIONWIDGET) {
1415             Transition *tr = static_cast <Transition *>(children.at(i));
1416             tr->updateItem();
1417             int track = tr->transitionEndTrack();
1418             if (track >= ix) {
1419                 ItemInfo clipinfo = tr->info();
1420                 tr->updateTransitionEndTrack(getPreviousVideoTrack(clipinfo.track));
1421             }
1422         }
1423     }
1424     resetSelectionGroup(false);
1425
1426     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), m_tracksHeight * m_document->tracksCount());
1427     setSceneRect(0, 0, sceneRect().width(), m_tracksHeight * m_document->tracksCount());
1428     verticalScrollBar()->setMaximum(m_tracksHeight * m_document->tracksCount());
1429     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
1430 }
1431
1432 void CustomTrackView::changeTrack(int ix, TrackInfo type) {
1433     int tracknumber = m_document->tracksCount() - ix;
1434     m_document->setTrackType(tracknumber - 1, type);
1435     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
1436     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
1437     viewport()->update();
1438 }
1439
1440
1441 void CustomTrackView::slotSwitchTrackAudio(int ix) {
1442     /*for (int i = 0; i < m_document->tracksCount(); i++)
1443         kDebug() << "TRK " << i << " STATE: " << m_document->trackInfoAt(i).isMute << m_document->trackInfoAt(i).isBlind;*/
1444
1445     int tracknumber = m_document->tracksCount() - ix;
1446
1447     m_document->switchTrackAudio(tracknumber - 1, !m_document->trackInfoAt(tracknumber - 1).isMute);
1448     kDebug() << "NEXT TRK STATE: " << m_document->trackInfoAt(tracknumber - 1).isMute << m_document->trackInfoAt(tracknumber - 1).isBlind;
1449     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
1450     m_document->setModified(true);
1451 }
1452
1453 void CustomTrackView::slotSwitchTrackVideo(int ix) {
1454     int tracknumber = m_document->tracksCount() - ix;
1455     m_document->switchTrackVideo(tracknumber - 1, !m_document->trackInfoAt(tracknumber - 1).isBlind);
1456     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
1457     m_document->setModified(true);
1458 }
1459
1460 void CustomTrackView::slotRemoveSpace() {
1461     GenTime pos;
1462     int track = 0;
1463     if (m_menuPosition.isNull()) {
1464         pos = GenTime(cursorPos(), m_document->fps());
1465         bool ok;
1466         track = QInputDialog::getInteger(this, i18n("Remove Space"), i18n("Track"), 0, 0, m_document->tracksCount() - 1, 1, &ok);
1467         if (!ok) return;
1468     } else {
1469         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
1470         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight);
1471     }
1472     ClipItem *item = getClipItemAt(pos, track);
1473     if (item) {
1474         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);
1475         return;
1476     }
1477     int length = m_document->renderer()->mltGetSpaceLength(pos, m_document->tracksCount() - track);
1478     //kDebug() << "// GOT LENGT; " << length;
1479     if (length <= 0) {
1480         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);
1481         return;
1482     }
1483     InsertSpaceCommand *command = new InsertSpaceCommand(this, pos, track, GenTime(-length, m_document->fps()), true);
1484     m_commandStack->push(command);
1485 }
1486
1487 void CustomTrackView::slotInsertSpace() {
1488     GenTime pos;
1489     int track = 0;
1490     if (m_menuPosition.isNull()) {
1491         pos = GenTime(cursorPos(), m_document->fps());
1492     } else {
1493         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
1494         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight) + 1;
1495     }
1496     SpacerDialog d(GenTime(65, m_document->fps()), m_document->timecode(), track, m_document->tracksCount(), this);
1497     if (d.exec() != QDialog::Accepted) return;
1498     GenTime spaceDuration = d.selectedDuration();
1499     track = d.selectedTrack();
1500     ClipItem *item = getClipItemAt(pos, track);
1501     if (item) pos = item->startPos();
1502
1503     InsertSpaceCommand *command = new InsertSpaceCommand(this, pos, track, spaceDuration, true);
1504     m_commandStack->push(command);
1505 }
1506
1507 void CustomTrackView::insertSpace(const GenTime &pos, int track, const GenTime duration) {
1508     int diff = duration.frames(m_document->fps());
1509     QList<QGraphicsItem *> itemList;
1510     if (track == -1) itemList = scene()->items(pos.frames(m_document->fps()) , 1, sceneRect().width() - pos.frames(m_document->fps()), sceneRect().height());
1511     else itemList = scene()->items(pos.frames(m_document->fps()) , track * m_tracksHeight + 1, sceneRect().width() - pos.frames(m_document->fps()), m_tracksHeight - 2);
1512     resetSelectionGroup();
1513     m_selectionGroup = new AbstractGroupItem(m_document->fps());
1514     scene()->addItem(m_selectionGroup);
1515     for (int i = 0; i < itemList.count(); i++) {
1516         if (itemList.at(i)->type() == AVWIDGET || itemList.at(i)->type() == TRANSITIONWIDGET) {
1517             m_selectionGroup->addToGroup(itemList.at(i));
1518             itemList.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
1519         }
1520     }
1521
1522     m_selectionGroup->translate(diff, 0);
1523     resetSelectionGroup(false);
1524     if (track != -1) track = m_document->tracksCount() - track;
1525     m_document->renderer()->mltInsertSpace(pos, track, duration);
1526 }
1527
1528 void CustomTrackView::deleteClip(const QString &clipId) {
1529     QList<QGraphicsItem *> itemList = items();
1530     for (int i = 0; i < itemList.count(); i++) {
1531         if (itemList.at(i)->type() == AVWIDGET) {
1532             ClipItem *item = (ClipItem *)itemList.at(i);
1533             if (item->clipProducer() == clipId) {
1534                 AddTimelineClipCommand *command = new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true);
1535                 m_commandStack->push(command);
1536                 //delete item;
1537             }
1538         }
1539     }
1540 }
1541
1542 void CustomTrackView::setCursorPos(int pos, bool seek) {
1543     emit cursorMoved((int)(m_cursorPos), (int)(pos));
1544     m_cursorPos = pos;
1545     m_cursorLine->setPos(pos, 0);
1546     if (seek) m_document->renderer()->seek(GenTime(pos, m_document->fps()));
1547     else if (m_autoScroll) checkScrolling();
1548 }
1549
1550 void CustomTrackView::updateCursorPos() {
1551     m_cursorLine->setPos(m_cursorPos, 0);
1552 }
1553
1554 int CustomTrackView::cursorPos() {
1555     return (int)(m_cursorPos);
1556 }
1557
1558 void CustomTrackView::moveCursorPos(int delta) {
1559     if (m_cursorPos + delta < 0) delta = 0 - m_cursorPos;
1560     emit cursorMoved((int)(m_cursorPos), (int)((m_cursorPos + delta)));
1561     m_cursorPos += delta;
1562     m_cursorLine->setPos(m_cursorPos, 0);
1563     m_document->renderer()->seek(GenTime(m_cursorPos, m_document->fps()));
1564     //if (m_autoScroll && m_scale < 50) checkScrolling();
1565 }
1566
1567 void CustomTrackView::checkScrolling() {
1568     int vert = verticalScrollBar()->value();
1569     int hor = cursorPos();
1570     ensureVisible(hor, vert + 10, 2, 2, 50, 0);
1571     //centerOn(QPointF(cursorPos(), m_tracksHeight));
1572     /*QRect rectInView = viewport()->rect();
1573     int delta = rectInView.width() / 3;
1574     int max = rectInView.right() + horizontalScrollBar()->value() - delta;
1575     //kDebug() << "CURSOR POS: "<<m_cursorPos<< "Scale: "<<m_scale;
1576     if (m_cursorPos * m_scale >= max) horizontalScrollBar()->setValue((int)(horizontalScrollBar()->value() + 1 + m_scale));*/
1577 }
1578
1579 void CustomTrackView::mouseReleaseEvent(QMouseEvent * event) {
1580     kDebug() << "// MOUSE RELEASED, MODE: " << m_moveOpMode;
1581     if (m_moveOpMode == SEEK) m_moveOpMode = NONE;
1582     QGraphicsView::mouseReleaseEvent(event);
1583     if (m_scrollTimer.isActive()) m_scrollTimer.stop();
1584     if (event->button() == Qt::MidButton) {
1585         return;
1586     }
1587     setDragMode(QGraphicsView::NoDrag);
1588     if (m_operationMode == MOVEGUIDE) {
1589         setCursor(Qt::ArrowCursor);
1590         m_operationMode = NONE;
1591         m_dragGuide->setFlag(QGraphicsItem::ItemIsMovable, false);
1592         EditGuideCommand *command = new EditGuideCommand(this, m_dragGuide->position(), m_dragGuide->label(), GenTime(m_dragGuide->pos().x(), m_document->fps()), m_dragGuide->label(), false);
1593         m_commandStack->push(command);
1594         m_dragGuide->updateGuide(GenTime(m_dragGuide->pos().x(), m_document->fps()));
1595         m_dragGuide = NULL;
1596         m_dragItem = NULL;
1597         return;
1598     } else if (m_operationMode == SPACER) {
1599         int endClick = (int)(mapToScene(event->pos()).x() + 0.5);
1600         int mappedClick = (int)(mapToScene(m_clickEvent).x() + 0.5);
1601         int track = (int)(mapToScene(m_clickEvent).y() / m_tracksHeight);
1602         if (m_selectionGroup->sceneBoundingRect().height() > m_tracksHeight) {
1603             // We are moving all tracks
1604             track = -1;
1605         }
1606         ClipItem *item = getClipItemAt(mappedClick, track);
1607         if (item) mappedClick = item->startPos().frames(m_document->fps());
1608         int diff = m_selectionGroup->pos().x() - m_spacerStart;//endClick - mappedClick;
1609         kDebug() << "// MOVING SPACER DIFF:" << diff;
1610         if (diff < 0) mappedClick += diff;
1611         InsertSpaceCommand *command = new InsertSpaceCommand(this, GenTime(mappedClick, m_document->fps()), track, GenTime(diff, m_document->fps()), false);
1612         m_commandStack->push(command);
1613         if (track != -1) track = m_document->tracksCount() - track;
1614         m_document->renderer()->mltInsertSpace(GenTime(mappedClick, m_document->fps()), track, GenTime(diff, m_document->fps()));
1615         resetSelectionGroup(false);
1616         m_operationMode = NONE;
1617     } else if (m_operationMode == RUBBERSELECTION) {
1618         resetSelectionGroup();
1619         groupSelectedItems();
1620         m_operationMode = NONE;
1621     }
1622
1623     if (m_dragItem == NULL && m_selectionGroup == NULL) {
1624         emit transitionItemSelected(NULL);
1625         return;
1626     }
1627     ItemInfo info;
1628     if (m_dragItem) info = m_dragItem->info();
1629
1630     if (m_operationMode == MOVE) {
1631         setCursor(Qt::OpenHandCursor);
1632
1633         if (m_selectionGroup == NULL) {
1634             // we are moving one clip, easy
1635             if (m_dragItem->type() == AVWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
1636                 ClipItem *item = static_cast <ClipItem *>(m_dragItem);
1637                 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));
1638                 if (success) {
1639                     MoveClipCommand *command = new MoveClipCommand(this, m_dragItemInfo, info, false, false);
1640                     m_commandStack->push(command);
1641                     if (item->baseClip()->isTransparent()) {
1642                         // Also move automatic transition
1643                         Transition *tr = getTransitionItemAt((int) m_dragItemInfo.startPos.frames(m_document->fps()), m_dragItemInfo.track);
1644                         if (tr && tr->isAutomatic()) {
1645                             tr->updateTransitionEndTrack(getPreviousVideoTrack(info.track));
1646                             m_document->renderer()->mltMoveTransition(tr->transitionTag(), m_document->tracksCount() - m_dragItemInfo.track, m_document->tracksCount() - info.track, tr->transitionEndTrack(), m_dragItemInfo.startPos, m_dragItemInfo.endPos, info.startPos, info.endPos);
1647                             tr->setPos((int) info.startPos.frames(m_document->fps()), (int)(info.track * m_tracksHeight + 1));
1648                         }
1649                     }
1650                 } else {
1651                     // undo last move and emit error message
1652                     MoveClipCommand *command = new MoveClipCommand(this, info, m_dragItemInfo, true);
1653                     m_commandStack->push(command);
1654                     emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(m_dragItemInfo.startPos.frames(m_document->fps()))), ErrorMessage);
1655                 }
1656             }
1657             if (m_dragItem->type() == TRANSITIONWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
1658                 MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
1659                 m_commandStack->push(command);
1660                 Transition *transition = (Transition *) m_dragItem;
1661                 transition->updateTransitionEndTrack(getPreviousVideoTrack(m_dragItem->track()));
1662                 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);
1663             }
1664         } else {
1665             // Moving several clips. We need to delete them and readd them to new position,
1666             // or they might overlap each other during the move
1667
1668             QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1669
1670             QList<ItemInfo> clipsToMove = QList<ItemInfo> ();
1671             QList<ItemInfo> transitionsToMove = QList<ItemInfo> ();
1672
1673             GenTime timeOffset = GenTime(m_selectionGroup->scenePos().x(), m_document->fps()) - m_selectionGroupInfo.startPos;
1674             const int trackOffset = m_selectionGroup->track() - m_selectionGroupInfo.track;
1675             if (timeOffset != GenTime() || trackOffset != 0) {
1676                 QUndoCommand *moveClips = new QUndoCommand();
1677                 moveClips->setText(i18n("Move group"));
1678                 // remove items in MLT playlist
1679                 for (int i = 0; i < items.count(); i++) {
1680                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
1681                     ItemInfo info = item->info();
1682                     if (item->type() == AVWIDGET) {
1683                         if (m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
1684                             // error, clip cannot be removed from playlist
1685                             emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
1686                         } else {
1687                             clipsToMove.append(info);
1688                         }
1689                     } else {
1690                         transitionsToMove.append(info);
1691                         Transition *tr = static_cast <Transition*>(item);
1692                         m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
1693                     }
1694                 }
1695
1696                 for (int i = 0; i < items.count(); i++) {
1697                     // re-add items in correct place
1698                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
1699                     item->updateItem();
1700                     ItemInfo info = item->info();
1701                     if (item->type() == AVWIDGET) {
1702                         ClipItem *clip = static_cast <ClipItem*>(item);
1703                         info.track = m_document->tracksCount() - info.track;
1704                         m_document->renderer()->mltInsertClip(info, clip->xml(), clip->baseClip()->producer(info.track));
1705                     } else {
1706                         Transition *tr = static_cast <Transition*>(item);
1707                         int newTrack = tr->transitionEndTrack();
1708                         if (!tr->forcedTrack()) {
1709                             newTrack += trackOffset;
1710                             if (newTrack < 0 || newTrack > m_document->tracksCount()) newTrack = getPreviousVideoTrack(info.track);
1711                         }
1712                         tr->updateTransitionEndTrack(newTrack);
1713                         m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
1714                     }
1715                 }
1716
1717                 new MoveGroupCommand(this, clipsToMove, transitionsToMove, timeOffset, trackOffset, false, moveClips);
1718                 m_commandStack->push(moveClips);
1719
1720                 QPointF top = m_selectionGroup->sceneBoundingRect().topLeft();
1721                 //QPointF oldpos = m_selectionGroup->scenePos();
1722                 //kDebug()<<"SELECTION GRP POS: "<<m_selectionGroup->scenePos()<<", TOP: "<<top;
1723                 m_selectionGroup->setPos(top);
1724                 m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
1725                 m_selectionGroupInfo.track = m_selectionGroup->track();
1726             }
1727         }
1728
1729     } else if (m_operationMode == RESIZESTART && m_dragItem->startPos() != m_dragItemInfo.startPos) {
1730         // resize start
1731         if (m_dragItem->type() == AVWIDGET) {
1732             ItemInfo resizeinfo = m_dragItemInfo;
1733             resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
1734             bool success = m_document->renderer()->mltResizeClipStart(resizeinfo, m_dragItem->startPos() - m_dragItemInfo.startPos);
1735             if (success) {
1736                 updateClipFade(static_cast <ClipItem *>(m_dragItem));
1737                 ResizeClipCommand *command = new ResizeClipCommand(this, m_dragItemInfo, info, false);
1738                 m_commandStack->push(command);
1739             } else {
1740                 m_dragItem->resizeStart((int) m_dragItemInfo.startPos.frames(m_document->fps()));
1741                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
1742             }
1743         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
1744             MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
1745             m_commandStack->push(command);
1746             Transition *transition = static_cast <Transition *>(m_dragItem);
1747             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);
1748         }
1749
1750         //m_document->renderer()->doRefresh();
1751     } else if (m_operationMode == RESIZEEND && m_dragItem->endPos() != m_dragItemInfo.endPos) {
1752         // resize end
1753         if (m_dragItem->type() == AVWIDGET) {
1754             ItemInfo resizeinfo = info;
1755             resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
1756             bool success = m_document->renderer()->mltResizeClipEnd(resizeinfo, resizeinfo.endPos - resizeinfo.startPos);
1757             if (success) {
1758                 ResizeClipCommand *command = new ResizeClipCommand(this, m_dragItemInfo, info, false);
1759                 m_commandStack->push(command);
1760                 updateClipFade(static_cast <ClipItem *>(m_dragItem), true);
1761             } else {
1762                 m_dragItem->resizeEnd((int) m_dragItemInfo.endPos.frames(m_document->fps()));
1763                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
1764             }
1765         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
1766             MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
1767             m_commandStack->push(command);
1768             Transition *transition = static_cast <Transition *>(m_dragItem);
1769             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);
1770         }
1771         //m_document->renderer()->doRefresh();
1772     } else if (m_operationMode == FADEIN) {
1773         // resize fade in effect
1774         ClipItem * item = (ClipItem *) m_dragItem;
1775         int ix = item->hasEffect("volume", "fadein");
1776         if (ix != -1) {
1777             QDomElement oldeffect = item->effectAt(ix);
1778             int start = item->cropStart().frames(m_document->fps());
1779             int end = item->fadeIn();
1780             if (end == 0) {
1781                 slotDeleteEffect(item, oldeffect);
1782             } else {
1783                 end += start;
1784                 QDomElement effect = oldeffect.cloneNode().toElement();
1785                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
1786                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
1787                 slotUpdateClipEffect(item, effect, oldeffect, ix);
1788                 emit clipItemSelected(item, ix);
1789             }
1790         } else if (item->fadeIn() != 0) {
1791             QDomElement effect = MainWindow::audioEffects.getEffectByTag("volume", "fadein").cloneNode().toElement();
1792             EffectsList::setParameter(effect, "out", QString::number(item->fadeIn()));
1793             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
1794         }
1795     } else if (m_operationMode == FADEOUT) {
1796         // resize fade in effect
1797         ClipItem * item = (ClipItem *) m_dragItem;
1798         int ix = item->hasEffect("volume", "fadeout");
1799         if (ix != -1) {
1800             QDomElement oldeffect = item->effectAt(ix);
1801             int end = (item->duration() + item->cropStart()).frames(m_document->fps());
1802             int start = item->fadeOut();
1803             if (start == 0) {
1804                 slotDeleteEffect(item, oldeffect);
1805             } else {
1806                 start = end - start;
1807                 QDomElement effect = oldeffect.cloneNode().toElement();
1808                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
1809                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
1810                 slotUpdateClipEffect(item, effect, oldeffect, ix);
1811                 emit clipItemSelected(item, ix);
1812             }
1813         } else if (item->fadeOut() != 0) {
1814             QDomElement effect = MainWindow::audioEffects.getEffectByTag("volume", "fadeout").cloneNode().toElement();
1815             EffectsList::setParameter(effect, "out", QString::number(item->fadeOut()));
1816             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
1817         }
1818     } else if (m_operationMode == KEYFRAME) {
1819         // update the MLT effect
1820         ClipItem * item = (ClipItem *) m_dragItem;
1821         QString previous = item->keyframes(item->selectedEffectIndex());
1822         item->updateKeyframeEffect();
1823         QString next = item->keyframes(item->selectedEffectIndex());
1824         EditKeyFrameCommand *command = new EditKeyFrameCommand(this, item->track(), item->startPos(), item->selectedEffectIndex(), previous, next, false);
1825         m_commandStack->push(command);
1826         updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
1827     }
1828
1829     emit transitionItemSelected((m_dragItem && m_dragItem->type() == TRANSITIONWIDGET) ? static_cast <Transition *>(m_dragItem) : NULL);
1830     m_document->setModified(true);
1831     m_operationMode = NONE;
1832 }
1833
1834 void CustomTrackView::deleteClip(ItemInfo info) {
1835     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
1836
1837     if (!item || m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
1838         emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
1839         return;
1840     }
1841     if (item->isSelected()) emit clipItemSelected(NULL);
1842     item->baseClip()->removeReference();
1843     m_document->updateClip(item->baseClip()->getId());
1844
1845     if (item->baseClip()->isTransparent()) {
1846         // also remove automatic transition
1847         Transition *tr = getTransitionItemAt((int) info.startPos.frames(m_document->fps()), info.track);
1848         if (tr && tr->isAutomatic()) {
1849             m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
1850             scene()->removeItem(tr);
1851             delete tr;
1852         }
1853     }
1854     scene()->removeItem(item);
1855     if (m_dragItem == item) m_dragItem = NULL;
1856     delete item;
1857     m_document->renderer()->doRefresh();
1858 }
1859
1860 void CustomTrackView::deleteSelectedClips() {
1861     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1862     if (itemList.count() == 0) {
1863         emit displayMessage(i18n("Select clip to delete"), ErrorMessage);
1864         return;
1865     }
1866     QUndoCommand *deleteSelected = new QUndoCommand();
1867     deleteSelected->setText(i18n("Delete selected items"));
1868     for (int i = 0; i < itemList.count(); i++) {
1869         if (itemList.at(i)->type() == AVWIDGET) {
1870             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
1871             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true, deleteSelected);
1872         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
1873             Transition *item = static_cast <Transition *>(itemList.at(i));
1874             ItemInfo info;
1875             info.startPos = item->startPos();
1876             info.endPos = item->endPos();
1877             info.track = item->track();
1878             new AddTransitionCommand(this, info, item->transitionEndTrack(), item->toXML(), true, true, deleteSelected);
1879         }
1880     }
1881     m_commandStack->push(deleteSelected);
1882 }
1883
1884 void CustomTrackView::changeClipSpeed() {
1885     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1886     if (itemList.count() == 0) {
1887         emit displayMessage(i18n("Select clip to change speed"), ErrorMessage);
1888         return;
1889     }
1890     QUndoCommand *changeSelected = new QUndoCommand();
1891     changeSelected->setText("Edit clip speed");
1892     for (int i = 0; i < itemList.count(); i++) {
1893         if (itemList.at(i)->type() == AVWIDGET) {
1894             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
1895             ItemInfo info = item->info();
1896             int percent = QInputDialog::getInteger(this, i18n("Edit Clip Speed"), i18n("New speed (percents)"), item->speed() * 100, 1, 300);
1897             double speed = (double) percent / 100.0;
1898             if (item->speed() != speed)
1899                 new ChangeSpeedCommand(this, info, item->speed(), speed, item->clipProducer(), true, changeSelected);
1900         }
1901     }
1902     m_commandStack->push(changeSelected);
1903 }
1904
1905 void CustomTrackView::doChangeClipSpeed(ItemInfo info, const double speed, const double oldspeed, const QString &id) {
1906     DocClipBase *baseclip = m_document->clipManager()->getClipById(id);
1907     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
1908     info.track = m_document->tracksCount() - item->track();
1909     int endPos = m_document->renderer()->mltChangeClipSpeed(info, speed, oldspeed, baseclip->producer());
1910     //kDebug() << "//CH CLIP SPEED: " << speed << "x" << oldspeed << ", END POS: " << endPos;
1911     item->setSpeed(speed);
1912     item->updateRectGeometry();
1913     if (item->cropDuration().frames(m_document->fps()) > endPos)
1914         item->AbstractClipItem::resizeEnd(info.startPos.frames(m_document->fps()) + endPos, speed);
1915     m_document->setModified(true);
1916 }
1917
1918 void CustomTrackView::cutSelectedClips() {
1919     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1920     GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
1921     for (int i = 0; i < itemList.count(); i++) {
1922         if (itemList.at(i)->type() == AVWIDGET) {
1923             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
1924             if (currentPos > item->startPos() && currentPos <  item->endPos()) {
1925                 RazorClipCommand *command = new RazorClipCommand(this, item->info(), currentPos, true);
1926                 m_commandStack->push(command);
1927             }
1928         }
1929     }
1930 }
1931
1932 void CustomTrackView::addClip(QDomElement xml, const QString &clipId, ItemInfo info, EffectsList effects) {
1933     DocClipBase *baseclip = m_document->clipManager()->getClipById(clipId);
1934     if (baseclip == NULL) {
1935         emit displayMessage(i18n("No clip copied"), ErrorMessage);
1936         return;
1937     }
1938     ClipItem *item = new ClipItem(baseclip, info, m_document->fps());
1939     item->setEffectList(effects);
1940     scene()->addItem(item);
1941     if (item->baseClip()->isTransparent()) {
1942         // add transparency transition
1943         int endTrack = getPreviousVideoTrack(info.track);
1944         Transition *tr = new Transition(info, endTrack, m_document->fps(), MainWindow::transitions.getEffectByTag("composite", "alphatransparency"), true);
1945         scene()->addItem(tr);
1946         m_document->renderer()->mltAddTransition(tr->transitionTag(), endTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
1947     }
1948
1949     baseclip->addReference();
1950     m_document->updateClip(baseclip->getId());
1951     info.track = m_document->tracksCount() - info.track;
1952     m_document->renderer()->mltInsertClip(info, xml, baseclip->producer(info.track));
1953     for (int i = 0; i < item->effectsCount(); i++) {
1954         m_document->renderer()->mltAddEffect(info.track, info.startPos, item->getEffectArgs(item->effectAt(i)), false);
1955     }
1956     m_document->renderer()->doRefresh();
1957 }
1958
1959 void CustomTrackView::slotUpdateClip(const QString &clipId) {
1960     QList<QGraphicsItem *> list = scene()->items();
1961     ClipItem *clip = NULL;
1962     for (int i = 0; i < list.size(); ++i) {
1963         if (list.at(i)->type() == AVWIDGET) {
1964             clip = static_cast <ClipItem *>(list.at(i));
1965             if (clip->clipProducer() == clipId) {
1966                 clip->refreshClip();
1967                 ItemInfo info = clip->info();
1968                 info.track = m_document->tracksCount() - clip->track();
1969                 m_document->renderer()->mltUpdateClip(info, clip->xml(), clip->baseClip()->producer());
1970             }
1971         }
1972     }
1973 }
1974
1975 ClipItem *CustomTrackView::getClipItemAt(int pos, int track) {
1976     QList<QGraphicsItem *> list = scene()->items(QPointF(pos , track * m_tracksHeight + m_tracksHeight / 2));
1977     ClipItem *clip = NULL;
1978     for (int i = 0; i < list.size(); ++i) {
1979         if (list.at(i)->type() == AVWIDGET) {
1980             clip = static_cast <ClipItem *>(list.at(i));
1981             break;
1982         }
1983     }
1984     return clip;
1985 }
1986
1987 ClipItem *CustomTrackView::getClipItemAt(GenTime pos, int track) {
1988     int framepos = (int)(pos.frames(m_document->fps()));
1989     return getClipItemAt(framepos, track);
1990 }
1991
1992 Transition *CustomTrackView::getTransitionItemAt(int pos, int track) {
1993     QList<QGraphicsItem *> list = scene()->items(QPointF(pos, (track + 1) * m_tracksHeight));
1994     Transition *clip = NULL;
1995     for (int i = 0; i < list.size(); ++i) {
1996         if (list.at(i)->type() == TRANSITIONWIDGET) {
1997             clip = static_cast <Transition *>(list.at(i));
1998             break;
1999         }
2000     }
2001     return clip;
2002 }
2003
2004 Transition *CustomTrackView::getTransitionItemAt(GenTime pos, int track) {
2005     int framepos = (int)(pos.frames(m_document->fps()));
2006     return getTransitionItemAt(framepos, track);
2007 }
2008
2009 void CustomTrackView::moveClip(const ItemInfo start, const ItemInfo end) {
2010     ClipItem *item = getClipItemAt((int) start.startPos.frames(m_document->fps()) + 1, start.track);
2011     if (!item) {
2012         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);
2013         kDebug() << "----------------  ERROR, CANNOT find clip to move at.. ";// << startPos.x() * m_scale * FRAME_SIZE + 1 << ", " << startPos.y() * m_tracksHeight + m_tracksHeight / 2;
2014         return;
2015     }
2016     //kDebug() << "----------------  Move CLIP FROM: " << startPos.x() << ", END:" << endPos.x() << ",TRACKS: " << startPos.y() << " TO " << endPos.y();
2017
2018     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));
2019     if (success) {
2020         item->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
2021         if (item->baseClip()->isTransparent()) {
2022             // Also move automatic transition
2023             Transition *tr = getTransitionItemAt((int) start.startPos.frames(m_document->fps()), start.track);
2024             if (tr && tr->isAutomatic()) {
2025                 tr->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
2026                 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);
2027                 tr->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
2028             }
2029         }
2030     } else {
2031         // undo last move and emit error message
2032         emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(end.startPos.frames(m_document->fps()))), ErrorMessage);
2033     }
2034 }
2035
2036 void CustomTrackView::moveGroup(QList <ItemInfo> startClip, QList <ItemInfo> startTransition, const GenTime offset, const int trackOffset, bool reverseMove) {
2037     // Group Items
2038     kDebug() << "// GROUP MOVE; OFFSET: " << offset.frames(25) << ", TK OFF: " << trackOffset;
2039     resetSelectionGroup();
2040     m_scene->clearSelection();
2041     for (int i = 0; i < startClip.count(); i++) {
2042         if (reverseMove) {
2043             startClip[i].startPos = startClip.at(i).startPos - offset;
2044             startClip[i].track = startClip.at(i).track - trackOffset;
2045         }
2046         ClipItem *clip = getClipItemAt(startClip.at(i).startPos, startClip.at(i).track);
2047         if (clip) {
2048             clip->setSelected(true);
2049             m_document->renderer()->mltRemoveClip(m_document->tracksCount() - startClip.at(i).track, startClip.at(i).startPos);
2050         }
2051     }
2052     for (int i = 0; i < startTransition.count(); i++) {
2053         if (reverseMove) {
2054             startTransition[i].startPos = startTransition.at(i).startPos - offset;
2055             startTransition[i].track = startTransition.at(i).track - trackOffset;
2056         }
2057         Transition *tr = getTransitionItemAt(startTransition.at(i).startPos, startTransition.at(i).track);
2058         if (tr) {
2059             tr->setSelected(true);
2060             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());
2061         }
2062     }
2063     groupSelectedItems();
2064     if (m_selectionGroup) {
2065         QPointF pos = m_selectionGroup->pos();
2066         qreal posx = pos.x() + offset.frames(m_document->fps());
2067         qreal posy = pos.y() + trackOffset * (qreal) m_tracksHeight;
2068         m_selectionGroup->setPos(posx, posy);
2069
2070         QPointF top = m_selectionGroup->sceneBoundingRect().topLeft();
2071         m_selectionGroup->setPos(top);
2072         m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
2073         m_selectionGroupInfo.track = m_selectionGroup->track();
2074
2075         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
2076         for (int i = 0; i < children.count(); i++) {
2077             // re-add items in correct place
2078             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
2079             item->updateItem();
2080             ItemInfo info = item->info();
2081             if (item->type() == AVWIDGET) {
2082                 ClipItem *clip = static_cast <ClipItem*>(item);
2083                 info.track = m_document->tracksCount() - info.track;
2084                 m_document->renderer()->mltInsertClip(info, clip->xml(), clip->baseClip()->producer(info.track));
2085             } else {
2086                 Transition *tr = static_cast <Transition*>(item);
2087                 int newTrack = tr->transitionEndTrack();
2088                 kDebug() << "/// TRANSITION CURR TRK: " << newTrack;
2089                 if (!tr->forcedTrack()) {
2090                     newTrack += trackOffset;
2091                     if (newTrack < 0 || newTrack > m_document->tracksCount()) newTrack = getPreviousVideoTrack(info.track);
2092                 }
2093                 tr->updateTransitionEndTrack(newTrack);
2094                 kDebug() << "/// TRANSITION UPDATED TRK: " << newTrack;
2095                 m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2096             }
2097         }
2098     }
2099
2100 }
2101
2102 void CustomTrackView::moveTransition(const ItemInfo start, const ItemInfo end) {
2103     Transition *item = getTransitionItemAt((int)start.startPos.frames(m_document->fps()), start.track);
2104     if (!item) {
2105         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);
2106         kDebug() << "----------------  ERROR, CANNOT find transition to move... ";// << startPos.x() * m_scale * FRAME_SIZE + 1 << ", " << startPos.y() * m_tracksHeight + m_tracksHeight / 2;
2107         return;
2108     }
2109     //kDebug() << "----------------  Move TRANSITION FROM: " << startPos.x() << ", END:" << endPos.x() << ",TRACKS: " << oldtrack << " TO " << newtrack;
2110
2111     //kDebug()<<"///  RESIZE TRANS START: ("<< startPos.x()<<"x"<< startPos.y()<<") / ("<<endPos.x()<<"x"<< endPos.y()<<")";
2112     if (end.endPos - end.startPos == start.endPos - start.startPos) {
2113         // Transition was moved
2114         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
2115     } else if (end.endPos == start.endPos) {
2116         // Transition start resize
2117         item->resizeStart((int) end.startPos.frames(m_document->fps()));
2118     } else {
2119         // Transition end resize;
2120         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
2121     }
2122     //item->moveTransition(GenTime((int) (endPos.x() - startPos.x()), m_document->fps()));
2123     item->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
2124     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);
2125 }
2126
2127 void CustomTrackView::resizeClip(const ItemInfo start, const ItemInfo end) {
2128     int offset = 0;
2129     bool resizeClipStart = true;
2130     if (start.startPos == end.startPos) resizeClipStart = false;
2131     /*if (resizeClipStart) offset = 1;
2132     else offset = -1;*/
2133     ClipItem *item = getClipItemAt((int)(start.startPos.frames(m_document->fps()) + offset), start.track);
2134     if (!item) {
2135         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);
2136         kDebug() << "----------------  ERROR, CANNOT find clip to resize at... "; // << startPos;
2137         return;
2138     }
2139     if (resizeClipStart) {
2140         ItemInfo clipinfo = item->info();
2141         clipinfo.track = m_document->tracksCount() - clipinfo.track;
2142         bool success = m_document->renderer()->mltResizeClipStart(clipinfo, end.startPos - item->startPos());
2143         if (success) {
2144             item->resizeStart((int) end.startPos.frames(m_document->fps()));
2145             updateClipFade(item);
2146         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2147     } else {
2148         ItemInfo clipinfo = item->info();
2149         clipinfo.track = m_document->tracksCount() - clipinfo.track;
2150         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, end.endPos - clipinfo.startPos);
2151         if (success) {
2152             item->resizeEnd((int) end.endPos.frames(m_document->fps()));
2153             updateClipFade(item, true);
2154         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2155     }
2156     m_document->renderer()->doRefresh();
2157 }
2158
2159 void CustomTrackView::updateClipFade(ClipItem * item, bool updateFadeOut) {
2160     if (!updateFadeOut) {
2161         int end = item->fadeIn();
2162         if (end != 0) {
2163             // there is a fade in effect
2164             int effectPos = item->hasEffect("volume", "fadein");
2165             if (effectPos == -1) return;
2166             QDomElement oldeffect = item->effectAt(effectPos);
2167             int start = item->cropStart().frames(m_document->fps());
2168             int max = item->cropDuration().frames(m_document->fps());
2169             if (end > max) {
2170                 item->setFadeIn(max);
2171                 end = item->fadeIn();
2172             }
2173             end += start;
2174             EffectsList::setParameter(oldeffect, "in", QString::number(start));
2175             EffectsList::setParameter(oldeffect, "out", QString::number(end));
2176             QHash <QString, QString> effectParams = item->getEffectArgs(oldeffect);
2177             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), effectParams))
2178                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
2179             // if fade effect is displayed, update the effect edit widget with new clip duration
2180             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
2181         }
2182     } else {
2183         int start = item->fadeOut();
2184         if (start != 0) {
2185             // there is a fade in effect
2186             int effectPos = item->hasEffect("volume", "fadeout");
2187             if (effectPos == -1) return;
2188             QDomElement oldeffect = item->effectAt(effectPos);
2189             int end = (item->duration() - item->cropStart()).frames(m_document->fps());
2190             int max = item->cropDuration().frames(m_document->fps());
2191             if (end > max) {
2192                 item->setFadeOut(max);
2193                 start = item->fadeOut();
2194             }
2195             start = end - start;
2196             EffectsList::setParameter(oldeffect, "in", QString::number(start));
2197             EffectsList::setParameter(oldeffect, "out", QString::number(end));
2198             QHash <QString, QString> effectParams = item->getEffectArgs(oldeffect);
2199             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), effectParams))
2200                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
2201             // if fade effect is displayed, update the effect edit widget with new clip duration
2202             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
2203         }
2204     }
2205 }
2206
2207 double CustomTrackView::getSnapPointForPos(double pos) {
2208     return m_scene->getSnapPointForPos(pos, KdenliveSettings::snaptopoints());
2209 }
2210
2211 void CustomTrackView::updateSnapPoints(AbstractClipItem *selected) {
2212     QList <GenTime> snaps;
2213     GenTime offset;
2214     if (selected) offset = selected->duration();
2215     QList<QGraphicsItem *> itemList = items();
2216     for (int i = 0; i < itemList.count(); i++) {
2217         if (itemList.at(i)->type() == AVWIDGET && itemList.at(i) != selected) {
2218             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2219             GenTime start = item->startPos();
2220             GenTime end = item->endPos();
2221             snaps.append(start);
2222             snaps.append(end);
2223             QList < GenTime > markers = item->snapMarkers();
2224             for (int i = 0; i < markers.size(); ++i) {
2225                 GenTime t = markers.at(i);
2226                 snaps.append(t);
2227                 if (t > offset) snaps.append(t - offset);
2228             }
2229             if (offset != GenTime()) {
2230                 if (start > offset) snaps.append(start - offset);
2231                 if (end > offset) snaps.append(end - offset);
2232             }
2233         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
2234             Transition *transition = static_cast <Transition*>(itemList.at(i));
2235             GenTime start = transition->startPos();
2236             GenTime end = transition->endPos();
2237             snaps.append(start);
2238             snaps.append(end);
2239             if (offset != GenTime()) {
2240                 if (start > offset) snaps.append(start - offset);
2241                 if (end > offset) snaps.append(end - offset);
2242             }
2243         }
2244     }
2245
2246     // add cursor position
2247     GenTime pos = GenTime(m_cursorPos, m_document->fps());
2248     snaps.append(pos);
2249     if (offset != GenTime()) snaps.append(pos - offset);
2250
2251     // add guides
2252     for (int i = 0; i < m_guides.count(); i++) {
2253         snaps.append(m_guides.at(i)->position());
2254         if (offset != GenTime()) snaps.append(m_guides.at(i)->position() - offset);
2255     }
2256
2257     qSort(snaps);
2258     m_scene->setSnapList(snaps);
2259     //for (int i = 0; i < m_snapPoints.size(); ++i)
2260     //    kDebug() << "SNAP POINT: " << m_snapPoints.at(i).frames(25);
2261 }
2262
2263 void CustomTrackView::slotSeekToPreviousSnap() {
2264     updateSnapPoints(NULL);
2265     GenTime res = m_scene->previousSnapPoint(GenTime(m_cursorPos, m_document->fps()));
2266     setCursorPos((int) res.frames(m_document->fps()));
2267     checkScrolling();
2268 }
2269
2270 void CustomTrackView::slotSeekToNextSnap() {
2271     updateSnapPoints(NULL);
2272     GenTime res = m_scene->nextSnapPoint(GenTime(m_cursorPos, m_document->fps()));
2273     setCursorPos((int) res.frames(m_document->fps()));
2274     checkScrolling();
2275 }
2276
2277 void CustomTrackView::clipStart() {
2278     ClipItem *item = getMainActiveClip();
2279     if (item != NULL) {
2280         setCursorPos((int) item->startPos().frames(m_document->fps()));
2281         checkScrolling();
2282     }
2283 }
2284
2285 void CustomTrackView::clipEnd() {
2286     ClipItem *item = getMainActiveClip();
2287     if (item != NULL) {
2288         setCursorPos((int) item->endPos().frames(m_document->fps()));
2289         checkScrolling();
2290     }
2291 }
2292
2293 void CustomTrackView::slotAddClipMarker(const QString &id, GenTime t, QString c) {
2294     QString oldcomment = m_document->clipManager()->getClipById(id)->markerComment(t);
2295     AddMarkerCommand *command = new AddMarkerCommand(this, oldcomment, c, id, t, true);
2296     m_commandStack->push(command);
2297 }
2298
2299 void CustomTrackView::slotDeleteClipMarker(const QString &comment, const QString &id, const GenTime &position) {
2300     AddMarkerCommand *command = new AddMarkerCommand(this, comment, QString(), id, position, true);
2301     m_commandStack->push(command);
2302 }
2303
2304 void CustomTrackView::slotDeleteAllClipMarkers(const QString &id) {
2305     DocClipBase *base = m_document->clipManager()->getClipById(id);
2306     QList <CommentedTime> markers = base->commentedSnapMarkers();
2307
2308     if (markers.isEmpty()) {
2309         emit displayMessage(i18n("Clip has no markers"), ErrorMessage);
2310         return;
2311     }
2312     QUndoCommand *deleteMarkers = new QUndoCommand();
2313     deleteMarkers->setText("Delete clip markers");
2314
2315     for (int i = 0; i < markers.size(); i++) {
2316         new AddMarkerCommand(this, markers.at(i).comment(), QString(), id, markers.at(i).time(), true, deleteMarkers);
2317     }
2318     m_commandStack->push(deleteMarkers);
2319 }
2320
2321 void CustomTrackView::addMarker(const QString &id, const GenTime &pos, const QString comment) {
2322     DocClipBase *base = m_document->clipManager()->getClipById(id);
2323     if (!comment.isEmpty()) base->addSnapMarker(pos, comment);
2324     else base->deleteSnapMarker(pos);
2325     m_document->setModified(true);
2326     viewport()->update();
2327 }
2328
2329 bool sortGuidesList(const Guide *g1 , const Guide *g2) {
2330     return (*g1).position() < (*g2).position();
2331 }
2332
2333 void CustomTrackView::editGuide(const GenTime oldPos, const GenTime pos, const QString &comment) {
2334     if (oldPos > GenTime() && pos > GenTime()) {
2335         // move guide
2336         for (int i = 0; i < m_guides.count(); i++) {
2337             if (m_guides.at(i)->position() == oldPos) {
2338                 Guide *item = m_guides.at(i);
2339                 item->updateGuide(pos, comment);
2340                 break;
2341             }
2342         }
2343     } else if (pos > GenTime()) addGuide(pos, comment);
2344     else {
2345         // remove guide
2346         bool found = false;
2347         for (int i = 0; i < m_guides.count(); i++) {
2348             if (m_guides.at(i)->position() == oldPos) {
2349                 Guide *item = m_guides.takeAt(i);
2350                 delete item;
2351                 found = true;
2352                 break;
2353             }
2354         }
2355         if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
2356     }
2357     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
2358     m_document->syncGuides(m_guides);
2359 }
2360
2361 bool CustomTrackView::addGuide(const GenTime pos, const QString &comment) {
2362     for (int i = 0; i < m_guides.count(); i++) {
2363         if (m_guides.at(i)->position() == pos) {
2364             emit displayMessage(i18n("A guide already exists at position %1", m_document->timecode().getTimecodeFromFrames(pos.frames(m_document->fps()))), ErrorMessage);
2365             return false;
2366         }
2367     }
2368     Guide *g = new Guide(this, pos, comment, m_document->fps(), m_tracksHeight * m_document->tracksCount());
2369     scene()->addItem(g);
2370     m_guides.append(g);
2371     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
2372     m_document->syncGuides(m_guides);
2373     return true;
2374 }
2375
2376 void CustomTrackView::slotAddGuide() {
2377     CommentedTime marker(GenTime(m_cursorPos, m_document->fps()), i18n("Guide"));
2378     MarkerDialog d(NULL, marker, m_document->timecode(), i18n("Add Guide"), this);
2379     if (d.exec() != QDialog::Accepted) return;
2380     if (addGuide(d.newMarker().time(), d.newMarker().comment())) {
2381         EditGuideCommand *command = new EditGuideCommand(this, GenTime(), QString(), d.newMarker().time(), d.newMarker().comment(), false);
2382         m_commandStack->push(command);
2383     }
2384 }
2385
2386 void CustomTrackView::slotEditGuide() {
2387     GenTime pos = GenTime(m_cursorPos, m_document->fps());
2388     bool found = false;
2389     for (int i = 0; i < m_guides.count(); i++) {
2390         if (m_guides.at(i)->position() == pos) {
2391             slotEditGuide(m_guides.at(i)->info());
2392             found = true;
2393             break;
2394         }
2395     }
2396     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
2397 }
2398
2399 void CustomTrackView::slotEditGuide(CommentedTime guide) {
2400     MarkerDialog d(NULL, guide, m_document->timecode(), i18n("Edit Guide"), this);
2401     if (d.exec() == QDialog::Accepted) {
2402         EditGuideCommand *command = new EditGuideCommand(this, guide.time(), guide.comment(), d.newMarker().time(), d.newMarker().comment(), true);
2403         m_commandStack->push(command);
2404     }
2405 }
2406
2407
2408 void CustomTrackView::slotDeleteGuide() {
2409     GenTime pos = GenTime(m_cursorPos, m_document->fps());
2410     bool found = false;
2411     for (int i = 0; i < m_guides.count(); i++) {
2412         if (m_guides.at(i)->position() == pos) {
2413             EditGuideCommand *command = new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true);
2414             m_commandStack->push(command);
2415             found = true;
2416             break;
2417         }
2418     }
2419     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
2420 }
2421
2422 void CustomTrackView::slotDeleteAllGuides() {
2423     QUndoCommand *deleteAll = new QUndoCommand();
2424     deleteAll->setText("Delete all guides");
2425     for (int i = 0; i < m_guides.count(); i++) {
2426         EditGuideCommand *command = new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true, deleteAll);
2427     }
2428     m_commandStack->push(deleteAll);
2429 }
2430
2431 void CustomTrackView::setTool(PROJECTTOOL tool) {
2432     m_tool = tool;
2433 }
2434
2435 void CustomTrackView::setScale(double scaleFactor) {
2436     QMatrix matrix;
2437     matrix = matrix.scale(scaleFactor, 1);
2438     m_scene->setScale(scaleFactor);
2439     //scale(scaleFactor, 1);
2440     m_animationTimer->stop();
2441     if (m_visualTip) {
2442         delete m_visualTip;
2443         m_visualTip = NULL;
2444     }
2445     if (m_animation) {
2446         delete m_animation;
2447         m_animation = NULL;
2448     }
2449     /*double pos = cursorPos() / m_scale;
2450     m_scale = scaleFactor;
2451     m_scene->setScale(m_scale);
2452     int vert = verticalScrollBar()->value();
2453     kDebug() << " HHHHHHHH  SCALING: " << m_scale;
2454     QList<QGraphicsItem *> itemList = items();
2455     for (int i = 0; i < itemList.count(); i++) {
2456         if (itemList.at(i)->type() == AVWIDGET || itemList.at(i)->type() == TRANSITIONWIDGET) {
2457             AbstractClipItem *clip = (AbstractClipItem *)itemList.at(i);
2458             clip->setRect(0, 0, (qreal) clip->duration().frames(m_document->fps()) * m_scale - .5, clip->rect().height());
2459             clip->setPos((qreal) clip->startPos().frames(m_document->fps()) * m_scale, clip->pos().y());
2460         }
2461     }
2462
2463     for (int i = 0; i < m_guides.count(); i++) {
2464         m_guides.at(i)->updatePosition(m_scale);
2465     }
2466
2467     setSceneRect(0, 0, (m_projectDuration + 100) * m_scale, sceneRect().height());
2468     updateCursorPos();*/
2469     setMatrix(matrix);
2470     centerOn(QPointF(cursorPos(), m_tracksHeight));
2471     //verticalScrollBar()->setValue(vert);*/
2472 }
2473
2474 void CustomTrackView::slotRefreshGuides() {
2475     if (KdenliveSettings::showmarkers()) {
2476         kDebug() << "// refresh GUIDES";
2477         for (int i = 0; i < m_guides.count(); i++) {
2478             m_guides.at(i)->update();
2479         }
2480     }
2481 }
2482
2483 void CustomTrackView::drawBackground(QPainter * painter, const QRectF & rect) {
2484     QColor base = palette().button().color();
2485     QRectF r = rect;
2486     r.setWidth(r.width() + 1);
2487     painter->setClipRect(r);
2488     painter->drawLine(r.left(), 0, r.right(), 0);
2489     uint max = m_document->tracksCount();
2490     for (uint i = 0; i < max;i++) {
2491         /*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)));
2492                else*/
2493         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)));
2494         painter->drawLine(r.left(), m_tracksHeight * (i + 1), r.right(), m_tracksHeight * (i + 1));
2495     }
2496     int lowerLimit = m_tracksHeight * m_document->tracksCount() + 1;
2497     if (height() > lowerLimit)
2498         painter->fillRect(QRectF(r.left(), lowerLimit, r.width(), height() - lowerLimit), QBrush(base));
2499 }
2500
2501 bool CustomTrackView::findString(const QString &text) {
2502     QString marker;
2503     for (int i = 0; i < m_searchPoints.size(); ++i) {
2504         marker = m_searchPoints.at(i).comment();
2505         if (marker.contains(text, Qt::CaseInsensitive)) {
2506             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
2507             int vert = verticalScrollBar()->value();
2508             int hor = cursorPos();
2509             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
2510             m_findIndex = i;
2511             return true;
2512         }
2513     }
2514     return false;
2515 }
2516
2517 bool CustomTrackView::findNextString(const QString &text) {
2518     QString marker;
2519     for (int i = m_findIndex + 1; i < m_searchPoints.size(); ++i) {
2520         marker = m_searchPoints.at(i).comment();
2521         if (marker.contains(text, Qt::CaseInsensitive)) {
2522             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
2523             int vert = verticalScrollBar()->value();
2524             int hor = cursorPos();
2525             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
2526             m_findIndex = i;
2527             return true;
2528         }
2529     }
2530     m_findIndex = -1;
2531     return false;
2532 }
2533
2534 void CustomTrackView::initSearchStrings() {
2535     m_searchPoints.clear();
2536     QList<QGraphicsItem *> itemList = items();
2537     for (int i = 0; i < itemList.count(); i++) {
2538         // parse all clip names
2539         if (itemList.at(i)->type() == AVWIDGET) {
2540             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2541             GenTime start = item->startPos();
2542             CommentedTime t(start, item->clipName());
2543             m_searchPoints.append(t);
2544             // add all clip markers
2545             QList < CommentedTime > markers = item->commentedSnapMarkers();
2546             m_searchPoints += markers;
2547         }
2548     }
2549
2550     // add guides
2551     for (int i = 0; i < m_guides.count(); i++) {
2552         m_searchPoints.append(m_guides.at(i)->info());
2553     }
2554
2555     qSort(m_searchPoints);
2556 }
2557
2558 void CustomTrackView::clearSearchStrings() {
2559     m_searchPoints.clear();
2560     m_findIndex = 0;
2561 }
2562
2563 void CustomTrackView::copyClip() {
2564     while (m_copiedItems.count() > 0) {
2565         delete m_copiedItems.takeFirst();
2566     }
2567     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2568     if (itemList.count() == 0) {
2569         emit displayMessage(i18n("Select a clip before copying"), ErrorMessage);
2570         return;
2571     }
2572     for (int i = 0; i < itemList.count(); i++) {
2573         if (itemList.at(i)->type() == AVWIDGET) {
2574             ClipItem *dup = static_cast <ClipItem *>(itemList.at(i));
2575             m_copiedItems.append(dup->clone(dup->info()));
2576         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
2577             Transition *dup = static_cast <Transition *>(itemList.at(i));
2578             m_copiedItems.append(dup->clone());
2579         }
2580     }
2581 }
2582
2583 bool CustomTrackView::canBePastedTo(ItemInfo info, int type) const {
2584     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));
2585     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
2586     for (int i = 0; i < collisions.count(); i++) {
2587         if (collisions.at(i)->type() == type) return false;
2588     }
2589     return true;
2590 }
2591
2592 bool CustomTrackView::canBePasted(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const {
2593     for (int i = 0; i < items.count(); i++) {
2594         ItemInfo info = items.at(i)->info();
2595         info.startPos += offset;
2596         info.endPos += offset;
2597         info.track += trackOffset;
2598         if (!canBePastedTo(info, items.at(i)->type())) return false;
2599     }
2600     return true;
2601 }
2602
2603 bool CustomTrackView::canBeMoved(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const {
2604     QPainterPath movePath;
2605     movePath.moveTo(0, 0);
2606
2607     for (int i = 0; i < items.count(); i++) {
2608         ItemInfo info = items.at(i)->info();
2609         info.startPos = info.startPos + offset;
2610         info.endPos = info.endPos + offset;
2611         info.track = info.track + trackOffset;
2612         if (info.startPos < GenTime()) {
2613             // No clip should go below 0
2614             return false;
2615         }
2616         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));
2617         movePath.addRect(rect);
2618     }
2619     QList<QGraphicsItem *> collisions = scene()->items(movePath, Qt::IntersectsItemBoundingRect);
2620     for (int i = 0; i < collisions.count(); i++) {
2621         if ((collisions.at(i)->type() == AVWIDGET || collisions.at(i)->type() == TRANSITIONWIDGET) && !items.contains(static_cast <AbstractClipItem *>(collisions.at(i)))) {
2622             kDebug() << "  ////////////   CLIP COLLISION, MOVE NOT ALLOWED";
2623             return false;
2624         }
2625     }
2626     return true;
2627 }
2628
2629 void CustomTrackView::pasteClip() {
2630     if (m_copiedItems.count() == 0) {
2631         emit displayMessage(i18n("No clip copied"), ErrorMessage);
2632         return;
2633     }
2634     QPoint position;
2635     if (m_menuPosition.isNull()) position = mapFromGlobal(QCursor::pos());
2636     else position = m_menuPosition;
2637     GenTime pos = GenTime((int)(mapToScene(position).x()), m_document->fps());
2638     int track = (int)(position.y() / m_tracksHeight);
2639     ItemInfo first = m_copiedItems.at(0)->info();
2640
2641     GenTime offset = pos - first.startPos;
2642     int trackOffset = track - first.track;
2643
2644     if (!canBePasted(m_copiedItems, offset, trackOffset)) {
2645         emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
2646         return;
2647     }
2648     QUndoCommand *pasteClips = new QUndoCommand();
2649     pasteClips->setText("Paste clips");
2650
2651     for (int i = 0; i < m_copiedItems.count(); i++) {
2652         // parse all clip names
2653         if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == AVWIDGET) {
2654             ClipItem *clip = static_cast <ClipItem *>(m_copiedItems.at(i));
2655             ItemInfo info;
2656             info.startPos = clip->startPos() + offset;
2657             info.endPos = clip->endPos() + offset;
2658             info.cropStart = clip->cropStart();
2659             info.track = clip->track() + trackOffset;
2660             if (canBePastedTo(info, AVWIDGET)) {
2661                 new AddTimelineClipCommand(this, clip->xml(), clip->clipProducer(), info, clip->effectList(), true, false, pasteClips);
2662             } else emit displayMessage(i18n("Cannot paste clip to selected place"), ErrorMessage);
2663         } else if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == TRANSITIONWIDGET) {
2664             Transition *tr = static_cast <Transition *>(m_copiedItems.at(i));
2665             ItemInfo info;
2666             info.startPos = tr->startPos() + offset;
2667             info.endPos = tr->endPos() + offset;
2668             info.track = tr->track() + trackOffset;
2669             if (canBePastedTo(info, TRANSITIONWIDGET)) {
2670                 new AddTransitionCommand(this, info, tr->transitionEndTrack() + trackOffset, tr->toXML(), false, true, pasteClips);
2671             } else emit displayMessage(i18n("Cannot paste transition to selected place"), ErrorMessage);
2672         }
2673     }
2674     m_commandStack->push(pasteClips);
2675 }
2676
2677 void CustomTrackView::pasteClipEffects() {
2678     if (m_copiedItems.count() != 1 || m_copiedItems.at(0)->type() != AVWIDGET) {
2679         emit displayMessage(i18n("You must copy exactly one clip before pasting effects"), ErrorMessage);
2680         return;
2681     }
2682     ClipItem *clip = static_cast < ClipItem *>(m_copiedItems.at(0));
2683     EffectsList effects = clip->effectList();
2684
2685     QUndoCommand *paste = new QUndoCommand();
2686     paste->setText("Paste effects");
2687
2688     QList<QGraphicsItem *> clips = scene()->selectedItems();
2689     for (int i = 0; i < clips.count(); ++i) {
2690         if (clips.at(i)->type() == AVWIDGET) {
2691             ClipItem *item = static_cast < ClipItem *>(clips.at(i));
2692             for (int i = 0; i < clip->effectsCount(); i++) {
2693                 new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), clip->effectAt(i), true, paste);
2694             }
2695         }
2696     }
2697     m_commandStack->push(paste);
2698 }
2699
2700
2701 ClipItem *CustomTrackView::getClipUnderCursor() const {
2702     QRectF rect((double) m_cursorPos, 0.0, 1.0, (double)(m_tracksHeight * m_document->tracksCount()));
2703     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
2704     for (int i = 0; i < collisions.count(); i++) {
2705         if (collisions.at(i)->type() == AVWIDGET) {
2706             return static_cast < ClipItem *>(collisions.at(i));
2707         }
2708     }
2709     return NULL;
2710 }
2711
2712 ClipItem *CustomTrackView::getMainActiveClip() const {
2713     QList<QGraphicsItem *> clips = scene()->selectedItems();
2714     if (clips.isEmpty()) {
2715         return getClipUnderCursor();
2716     } else {
2717         ClipItem *item = NULL;
2718         for (int i = 0; i < clips.count(); ++i) {
2719             if (clips.at(i)->type() == AVWIDGET)
2720                 item = static_cast < ClipItem *>(clips.at(i));
2721             if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos) break;
2722         }
2723         if (item) return item;
2724     }
2725     return NULL;
2726 }
2727
2728 ClipItem *CustomTrackView::getActiveClipUnderCursor(bool allowOutsideCursor) const {
2729     QList<QGraphicsItem *> clips = scene()->selectedItems();
2730     if (clips.isEmpty()) {
2731         return getClipUnderCursor();
2732     } else {
2733         ClipItem *item;
2734         // remove all items in the list that are not clips
2735         for (int i = 0; i < clips.count();) {
2736             if (clips.at(i)->type() != AVWIDGET) clips.removeAt(i);
2737             else i++;
2738         }
2739         if (clips.count() == 1 && allowOutsideCursor) return static_cast < ClipItem *>(clips.at(0));
2740         for (int i = 0; i < clips.count(); ++i) {
2741             if (clips.at(i)->type() == AVWIDGET)
2742                 item = static_cast < ClipItem *>(clips.at(i));
2743             if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos) return item;
2744         }
2745     }
2746     return NULL;
2747 }
2748
2749 void CustomTrackView::setInPoint() {
2750     ClipItem *clip = getActiveClipUnderCursor(true);
2751     if (clip == NULL) {
2752         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
2753         return;
2754     }
2755     ItemInfo startInfo = clip->info();
2756     ItemInfo endInfo = clip->info();
2757     endInfo.startPos = GenTime(m_cursorPos, m_document->fps());
2758     ResizeClipCommand *command = new ResizeClipCommand(this, startInfo, endInfo, true);
2759     m_commandStack->push(command);
2760 }
2761
2762 void CustomTrackView::setOutPoint() {
2763     ClipItem *clip = getActiveClipUnderCursor(true);
2764     if (clip == NULL) {
2765         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
2766         return;
2767     }
2768     ItemInfo startInfo = clip->info();
2769     ItemInfo endInfo = clip->info();
2770     endInfo.endPos = GenTime(m_cursorPos, m_document->fps());
2771     ResizeClipCommand *command = new ResizeClipCommand(this, startInfo, endInfo, true);
2772     m_commandStack->push(command);
2773 }
2774
2775 void CustomTrackView::slotUpdateAllThumbs() {
2776     QList<QGraphicsItem *> itemList = items();
2777     ClipItem *item;
2778     Transition *transitionitem;
2779     for (int i = 0; i < itemList.count(); i++) {
2780         if (itemList.at(i)->type() == AVWIDGET) {
2781             item = static_cast <ClipItem *>(itemList.at(i));
2782             item->refreshClip();
2783             qApp->processEvents();
2784         }
2785     }
2786 }
2787
2788 void CustomTrackView::slotInsertTrack(int ix) {
2789     kDebug() << "// INSERTING TRK: " << ix;
2790     QDialog d(parentWidget());
2791     Ui::AddTrack_UI view;
2792     view.setupUi(&d);
2793     view.track_nb->setMaximum(m_document->tracksCount() - 1);
2794     view.track_nb->setValue(ix);
2795     d.setWindowTitle(i18n("Insert Track"));
2796
2797     if (d.exec() == QDialog::Accepted) {
2798         if (view.before_select->currentIndex() == 1) {
2799             ix++;
2800         }
2801         TrackInfo info;
2802         if (view.video_track->isChecked()) {
2803             info.type = VIDEOTRACK;
2804             info.isMute = false;
2805             info.isBlind = false;
2806         } else {
2807             info.type = AUDIOTRACK;
2808             info.isMute = false;
2809             info.isBlind = true;
2810         }
2811         AddTrackCommand *addTrack = new AddTrackCommand(this, ix, info, true, true);
2812         m_commandStack->push(addTrack);
2813         m_document->setModified(true);
2814     }
2815 }
2816
2817 void CustomTrackView::slotDeleteTrack(int ix) {
2818     bool ok;
2819     ix = QInputDialog::getInteger(this, i18n("Remove Track"), i18n("Track"), ix, 0, m_document->tracksCount() - 1, 1, &ok);
2820     if (ok) {
2821         TrackInfo info = m_document->trackInfoAt(m_document->tracksCount() - ix - 1);
2822         deleteTimelineTrack(ix, info);
2823         m_document->setModified(true);
2824         /*AddTrackCommand* command = new AddTrackCommand(this, ix, info, false, true);
2825         m_commandStack->push(command);*/
2826     }
2827 }
2828
2829 void CustomTrackView::slotChangeTrack(int ix) {
2830     QDialog d(parentWidget());
2831     Ui::AddTrack_UI view;
2832     view.setupUi(&d);
2833     view.label->setText(i18n("Change track"));
2834     view.before_select->setHidden(true);
2835     view.track_nb->setMaximum(m_document->tracksCount() - 1);
2836     view.track_nb->setValue(ix);
2837     d.setWindowTitle(i18n("Change Track Type"));
2838
2839     if (d.exec() == QDialog::Accepted) {
2840         TrackInfo info;
2841         if (view.video_track->isChecked()) {
2842             info.type = VIDEOTRACK;
2843             info.isMute = false;
2844             info.isBlind = false;
2845         } else {
2846             info.type = AUDIOTRACK;
2847             info.isMute = false;
2848             info.isBlind = true;
2849         }
2850         changeTimelineTrack(ix, info);
2851         m_document->setModified(true);
2852     }
2853 }
2854
2855
2856 void CustomTrackView::deleteTimelineTrack(int ix, TrackInfo trackinfo) {
2857     double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
2858     QRectF r(0, startY, sceneRect().width(), m_tracksHeight / 2 - 1);
2859     QList<QGraphicsItem *> selection = m_scene->items(r);
2860     QUndoCommand *deleteTrack = new QUndoCommand();
2861     deleteTrack->setText("Delete track");
2862
2863     // Delete all clips in selected track
2864     for (int i = 0; i < selection.count(); i++) {
2865         if (selection.at(i)->type() == AVWIDGET) {
2866             ClipItem *item =  static_cast <ClipItem *>(selection.at(i));
2867             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, true, deleteTrack);
2868             m_scene->removeItem(item);
2869             delete item;
2870             item = NULL;
2871         } else if (selection.at(i)->type() == TRANSITIONWIDGET) {
2872             Transition *item =  static_cast <Transition *>(selection.at(i));
2873             new AddTransitionCommand(this, item->info(), item->transitionEndTrack(), item->toXML(), true, false, deleteTrack);
2874             m_scene->removeItem(item);
2875             delete item;
2876             item = NULL;
2877         }
2878     }
2879
2880     new AddTrackCommand(this, ix, trackinfo, false, true, deleteTrack);
2881     m_commandStack->push(deleteTrack);
2882 }
2883
2884 void CustomTrackView::changeTimelineTrack(int ix, TrackInfo trackinfo) {
2885     TrackInfo oldinfo = m_document->trackInfoAt(m_document->tracksCount() - ix);
2886     ChangeTrackCommand *changeTrack = new ChangeTrackCommand(this, ix, oldinfo, trackinfo, true);
2887     m_commandStack->push(changeTrack);
2888 }
2889
2890 #include "customtrackview.moc"