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