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
  65
  66 //TODO:
  67 // disable animation if user asked it in KDE's global settings
  68 // http://lists.kde.org/?l=kde-commits&m=120398724717624&w=2
  69 // needs something like below (taken from dolphin)
  70 // #include <kglobalsettings.h>
  71 // const bool animate = KGlobalSettings::graphicEffectsLevel() & KGlobalSettings::SimpleAnimationEffects;
  72 // const int duration = animate ? 1500 : 1;
  73
  74 CustomTrackView::CustomTrackView(KdenliveDoc *doc, CustomTrackScene* projectscene, QWidget *parent)
  75         : QGraphicsView(projectscene, parent), m_scene(projectscene), m_cursorPos(0), m_dropItem(NULL), 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) {
  76     if (doc) m_commandStack = doc->commandStack();
  77     else m_commandStack == NULL;
  78     setMouseTracking(true);
  79     setAcceptDrops(true);
  80     m_animationTimer = new QTimeLine(800);
  81     m_animationTimer->setFrameRange(0, 5);
  82     m_animationTimer->setUpdateInterval(100);
  83     m_animationTimer->setLoopCount(0);
  84     m_tipColor = QColor(0, 192, 0, 200);
  85     QColor border = QColor(255, 255, 255, 100);
  86     m_tipPen.setColor(border);
  87     m_tipPen.setWidth(3);
  88     setContentsMargins(0, 0, 0, 0);
  89     if (projectscene) {
  90         m_cursorLine = projectscene->addLine(0, 0, 0, m_tracksHeight);
  91         m_cursorLine->setFlags(QGraphicsItem::ItemIsMovable);
  92         m_cursorLine->setZValue(1000);
  93     }
  94
  95     KIcon razorIcon("edit-cut");
  96     m_razorCursor = QCursor(razorIcon.pixmap(22, 22));
  97     verticalScrollBar()->setTracking(true);
  98     connect(verticalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(slotRefreshGuides()));
  99 }
 100
 101 CustomTrackView::~CustomTrackView() {
 102     qDeleteAll(m_guides);
 103 }
 104
 105 void CustomTrackView::setDocumentModified() {
 106     m_document->setModified(true);
 107 }
 108
 109 void CustomTrackView::setContextMenu(QMenu *timeline, QMenu *clip, QMenu *transition) {
 110     m_timelineContextMenu = timeline;
 111     m_timelineContextClipMenu = clip;
 112     m_timelineContextTransitionMenu = transition;
 113 }
 114
 115 void CustomTrackView::checkAutoScroll() {
 116     m_autoScroll = KdenliveSettings::autoscroll();
 117 }
 118
 119 QList <TrackInfo> CustomTrackView::tracksList() const {
 120     return m_scene->m_tracksList;
 121 }
 122
 123 void CustomTrackView::checkTrackHeight() {
 124     if (m_tracksHeight == KdenliveSettings::trackheight()) return;
 125     m_tracksHeight = KdenliveSettings::trackheight();
 126     emit trackHeightChanged();
 127     QList<QGraphicsItem *> itemList = items();
 128     ClipItem *item;
 129     Transition *transitionitem;
 130     for (int i = 0; i < itemList.count(); i++) {
 131         if (itemList.at(i)->type() == AVWIDGET) {
 132             item = (ClipItem*) itemList.at(i);
 133             item->setRect(0, 0, item->rect().width() - 0.02, m_tracksHeight - 1);
 134             item->setPos((qreal) item->startPos().frames(m_document->fps()), (qreal) item->track() * m_tracksHeight + 1);
 135             item->resetThumbs();
 136         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
 137             transitionitem = (Transition*) itemList.at(i);
 138             transitionitem->setRect(0, 0, transitionitem->rect().width() - 0.02, m_tracksHeight / 3 * 2 - 1);
 139             transitionitem->setPos((qreal) transitionitem->startPos().frames(m_document->fps()), (qreal) transitionitem->track() * m_tracksHeight + m_tracksHeight / 3 * 2);
 140         }
 141     }
 142     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), m_tracksHeight * m_scene->m_tracksList.count());
 143
 144     for (int i = 0; i < m_guides.count(); i++) {
 145         QLineF l = m_guides.at(i)->line();
 146         l.setP2(QPointF(l.x2(), m_tracksHeight * m_scene->m_tracksList.count()));
 147         m_guides.at(i)->setLine(l);
 148     }
 149
 150     setSceneRect(0, 0, sceneRect().width(), m_tracksHeight * m_scene->m_tracksList.count());
 151     verticalScrollBar()->setMaximum(m_tracksHeight * m_scene->m_tracksList.count());
 152     update();
 153 }
 154
 155 // virtual
 156 void CustomTrackView::resizeEvent(QResizeEvent * event) {
 157     QGraphicsView::resizeEvent(event);
 158 }
 159
 160 // virtual
 161 void CustomTrackView::wheelEvent(QWheelEvent * e) {
 162     if (e->modifiers() == Qt::ControlModifier) {
 163         if (e->delta() > 0) emit zoomIn();
 164         else emit zoomOut();
 165     } else {
 166         if (e->delta() > 0) horizontalScrollBar()->setValue(horizontalScrollBar()->value() + horizontalScrollBar()->singleStep());
 167         else  horizontalScrollBar()->setValue(horizontalScrollBar()->value() - horizontalScrollBar()->singleStep());
 168     }
 169 }
 170
 171 int CustomTrackView::getPreviousVideoTrack(int track) {
 172     track = m_scene->m_tracksList.count() - track - 1;
 173     track --;
 174     for (int i = track; i > -1; i--) {
 175         if (m_scene->m_tracksList.at(i).type == VIDEOTRACK) return i + 1;
 176     }
 177     return 0;
 178 }
 179
 180 // virtual
 181
 182 void CustomTrackView::mouseMoveEvent(QMouseEvent * event) {
 183     int pos = event->x();
 184     emit mousePosition((int)(mapToScene(event->pos()).x()));
 185     if (event->buttons() & Qt::MidButton) return;
 186     if (event->buttons() != Qt::NoButton) {
 187         if (m_dragItem && m_tool == SELECTTOOL) {
 188             if (m_operationMode == MOVE) {
 189                 QGraphicsView::mouseMoveEvent(event);
 190
 191                 /*&& (event->pos() - m_clickEvent).manhattanLength() >= QApplication::startDragDistance()) {
 192                            double snappedPos = getSnapPointForPos(mapToScene(event->pos()).x() - m_clickPoint.x());
 193                            //kDebug() << "///////  MOVE CLIP, EVENT Y: "<<m_clickPoint.y();//<<event->scenePos().y()<<", SCENE HEIGHT: "<<scene()->sceneRect().height();
 194                            int moveTrack = (int)  mapToScene(event->pos() - QPoint(0, (m_dragItem->type() == TRANSITIONWIDGET ? m_dragItem->boundingRect().height() / 2 : 0))).y() / m_tracksHeight;
 195                            int currentTrack = m_dragItem->track();
 196
 197                            if (moveTrack > 1000) moveTrack = 0;
 198                            else if (moveTrack > m_scene->m_tracksList.count() - 1) moveTrack = m_scene->m_tracksList.count() - 1;
 199                            else if (moveTrack < 0) moveTrack = 0;
 200
 201                            int offset = moveTrack - currentTrack;
 202                            if (m_selectedClipList.count() == 1) m_dragItem->moveTo((int)(snappedPos / m_scale), m_scale, offset * m_tracksHeight, moveTrack);
 203                            else {
 204                                int moveOffset = (int)(snappedPos / m_scale) - m_dragItem->startPos().frames(m_document->fps());
 205                                if (canBeMoved(m_selectedClipList, GenTime(moveOffset, m_document->fps()), offset)) {
 206                                    for (int i = 0; i < m_selectedClipList.count(); i++) {
 207                                        AbstractClipItem *item = m_selectedClipList.at(i);
 208                                        item->moveTo(item->startPos().frames(m_document->fps()) + moveOffset, m_scale, offset * m_tracksHeight, item->track() + offset, false);
 209                                    }
 210                                }
 211                            }*/
 212
 213             } else if (m_operationMode == RESIZESTART) {
 214                 double snappedPos = getSnapPointForPos(mapToScene(event->pos()).x());
 215                 m_dragItem->resizeStart((int)(snappedPos));
 216             } else if (m_operationMode == RESIZEEND) {
 217                 double snappedPos = getSnapPointForPos(mapToScene(event->pos()).x());
 218                 m_dragItem->resizeEnd((int)(snappedPos));
 219             } else if (m_operationMode == FADEIN) {
 220                 int pos = (int)(mapToScene(event->pos()).x());
 221                 ((ClipItem*) m_dragItem)->setFadeIn((int)(pos - m_dragItem->startPos().frames(m_document->fps())));
 222             } else if (m_operationMode == FADEOUT) {
 223                 int pos = (int)(mapToScene(event->pos()).x());
 224                 ((ClipItem*) m_dragItem)->setFadeOut((int)(m_dragItem->endPos().frames(m_document->fps()) - pos));
 225             } else if (m_operationMode == KEYFRAME) {
 226                 GenTime keyFramePos = GenTime((int)(mapToScene(event->pos()).x()), m_document->fps()) - m_dragItem->startPos() + m_dragItem->cropStart();
 227                 double pos = mapToScene(event->pos()).toPoint().y();
 228                 QRectF br = m_dragItem->sceneBoundingRect();
 229                 double maxh = 100.0 / br.height();
 230                 pos = (br.bottom() - pos) * maxh;
 231                 m_dragItem->updateKeyFramePos(keyFramePos, pos);
 232             }
 233
 234             if (m_animation) delete m_animation;
 235             m_animation = NULL;
 236             if (m_visualTip) delete m_visualTip;
 237             m_visualTip = NULL;
 238             return;
 239         } else if (m_operationMode == MOVEGUIDE) {
 240             if (m_animation) delete m_animation;
 241             m_animation = NULL;
 242             if (m_visualTip) delete m_visualTip;
 243             m_visualTip = NULL;
 244             QGraphicsView::mouseMoveEvent(event);
 245             return;
 246         }
 247     }
 248
 249     if (m_tool == RAZORTOOL) {
 250         setCursor(m_razorCursor);
 251         //QGraphicsView::mouseMoveEvent(event);
 252         //return;
 253     }
 254
 255     QList<QGraphicsItem *> itemList = items(event->pos());
 256     QGraphicsRectItem *item = NULL;
 257     OPERATIONTYPE opMode = NONE;
 258
 259     if (itemList.count() == 1 && itemList.at(0)->type() == GUIDEITEM) {
 260         opMode = MOVEGUIDE;
 261     } else for (int i = 0; i < itemList.count(); i++) {
 262             if (itemList.at(i)->type() == AVWIDGET || itemList.at(i)->type() == TRANSITIONWIDGET) {
 263                 item = (QGraphicsRectItem*) itemList.at(i);
 264                 break;
 265             }
 266         }
 267
 268     if (item && event->buttons() == Qt::NoButton) {
 269         AbstractClipItem *clip = static_cast <AbstractClipItem*>(item);
 270         if (m_tool == RAZORTOOL) {
 271             // razor tool over a clip, display current frame in monitor
 272             if (!m_blockRefresh && item->type() == AVWIDGET) {
 273                 //TODO: solve crash when showing frame when moving razor over clip
 274                 //emit showClipFrame(((ClipItem *) item)->baseClip(), mapToScene(event->pos()).x() / m_scale - (clip->startPos() - clip->cropStart()).frames(m_document->fps()));
 275             }
 276             event->accept();
 277             return;
 278         }
 279         opMode = clip->operationMode(mapToScene(event->pos()));
 280         double size = 5;
 281         if (opMode == m_moveOpMode) {
 282             QGraphicsView::mouseMoveEvent(event);
 283             return;
 284         } else {
 285             if (m_visualTip) {
 286                 if (m_animation) delete m_animation;
 287                 m_animation = NULL;
 288                 m_animationTimer->stop();
 289                 delete m_visualTip;
 290                 m_visualTip = NULL;
 291             }
 292         }
 293         m_moveOpMode = opMode;
 294         if (opMode == MOVE) {
 295             setCursor(Qt::OpenHandCursor);
 296         } else if (opMode == RESIZESTART) {
 297             setCursor(KCursor("left_side", Qt::SizeHorCursor));
 298             if (m_visualTip == NULL) {
 299                 QRectF rect = clip->sceneBoundingRect();
 300                 QPolygon polygon;
 301                 polygon << QPoint(0, rect.height() / 2 - size * 2);
 302                 polygon << QPoint(size * 2, (int)(rect.height() / 2));
 303                 polygon << QPoint(0, (int)(rect.height() / 2 + size * 2));
 304                 polygon << QPoint(0, (int)(rect.height() / 2 - size * 2));
 305
 306                 m_visualTip = new QGraphicsPolygonItem(polygon);
 307                 ((QGraphicsPolygonItem*) m_visualTip)->setBrush(m_tipColor);
 308                 ((QGraphicsPolygonItem*) m_visualTip)->setPen(m_tipPen);
 309                 m_visualTip->setPos(rect.x(), rect.y());
 310                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 311                 m_visualTip->setZValue(100);
 312                 m_animation = new QGraphicsItemAnimation;
 313                 m_animation->setItem(m_visualTip);
 314                 m_animation->setTimeLine(m_animationTimer);
 315                 double scale = 2.0;
 316                 m_animation->setScaleAt(.5, scale, 1);
 317                 //m_animation->setPosAt(.5, QPointF(rect.x() - rect.x() * scale, 0));
 318                 scale = 1.0;
 319                 m_animation->setScaleAt(1, scale, 1);
 320                 //m_animation->setPosAt(1, QPointF(rect.x() - rect.x() * scale, 0));
 321                 scene()->addItem(m_visualTip);
 322                 m_animationTimer->start();
 323             }
 324         } else if (opMode == RESIZEEND) {
 325             setCursor(KCursor("right_side", Qt::SizeHorCursor));
 326             if (m_visualTip == NULL) {
 327                 QRectF rect = clip->sceneBoundingRect();
 328                 QPolygon polygon;
 329                 polygon << QPoint(0, (int)(rect.height() / 2 - size * 2));
 330                 polygon << QPoint(- size * 2, (int)(rect.height() / 2));
 331                 polygon << QPoint(0, (int)(rect.height() / 2 + size * 2));
 332                 polygon << QPoint(0, (int)(rect.height() / 2 - size * 2));
 333
 334                 m_visualTip = new QGraphicsPolygonItem(polygon);
 335                 ((QGraphicsPolygonItem*) m_visualTip)->setBrush(m_tipColor);
 336                 ((QGraphicsPolygonItem*) m_visualTip)->setPen(m_tipPen);
 337                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 338                 m_visualTip->setPos(rect.right(), rect.y());
 339                 m_visualTip->setZValue(100);
 340                 m_animation = new QGraphicsItemAnimation;
 341                 m_animation->setItem(m_visualTip);
 342                 m_animation->setTimeLine(m_animationTimer);
 343                 double scale = 2.0;
 344                 m_animation->setScaleAt(.5, scale, 1);
 345                 scale = 1.0;
 346                 m_animation->setScaleAt(1, scale, 1);
 347                 scene()->addItem(m_visualTip);
 348                 m_animationTimer->start();
 349             }
 350         } else if (opMode == FADEIN) {
 351             if (m_visualTip == NULL) {
 352                 ClipItem *item = (ClipItem *) clip;
 353                 QRectF rect = clip->sceneBoundingRect();
 354                 m_visualTip = new QGraphicsEllipseItem(-size, -size, size * 2, size * 2);
 355                 ((QGraphicsEllipseItem*) m_visualTip)->setBrush(m_tipColor);
 356                 ((QGraphicsEllipseItem*) m_visualTip)->setPen(m_tipPen);
 357                 m_visualTip->setPos(rect.x() + item->fadeIn(), rect.y());
 358                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 359                 m_visualTip->setZValue(100);
 360                 m_animation = new QGraphicsItemAnimation;
 361                 m_animation->setItem(m_visualTip);
 362                 m_animation->setTimeLine(m_animationTimer);
 363                 double scale = 2.0;
 364                 m_animation->setScaleAt(.5, scale, scale);
 365                 scale = 1.0;
 366                 m_animation->setScaleAt(1, scale, scale);
 367                 scene()->addItem(m_visualTip);
 368                 m_animationTimer->start();
 369             }
 370             setCursor(Qt::PointingHandCursor);
 371         } else if (opMode == FADEOUT) {
 372             if (m_visualTip == NULL) {
 373                 ClipItem *item = (ClipItem *) clip;
 374                 QRectF rect = clip->sceneBoundingRect();
 375                 m_visualTip = new QGraphicsEllipseItem(-size, -size, size * 2, size * 2);
 376                 ((QGraphicsEllipseItem*) m_visualTip)->setBrush(m_tipColor);
 377                 ((QGraphicsEllipseItem*) m_visualTip)->setPen(m_tipPen);
 378                 m_visualTip->setPos(rect.right() - item->fadeOut(), rect.y());
 379                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 380                 m_visualTip->setZValue(100);
 381                 m_animation = new QGraphicsItemAnimation;
 382                 m_animation->setItem(m_visualTip);
 383                 m_animation->setTimeLine(m_animationTimer);
 384                 double scale = 2.0;
 385                 m_animation->setScaleAt(.5, scale, scale);
 386                 scale = 1.0;
 387                 m_animation->setScaleAt(1, scale, scale);
 388                 scene()->addItem(m_visualTip);
 389                 m_animationTimer->start();
 390             }
 391             setCursor(Qt::PointingHandCursor);
 392         } else if (opMode == TRANSITIONSTART) {
 393             /*if (m_visualTip == NULL) {
 394                 QRectF rect = clip->sceneBoundingRect();
 395                 m_visualTip = new QGraphicsEllipseItem(-5, -5 , 10, 10);
 396                 ((QGraphicsEllipseItem*) m_visualTip)->setBrush(m_tipColor);
 397                 ((QGraphicsEllipseItem*) m_visualTip)->setPen(m_tipPen);
 398                 m_visualTip->setZValue(100);
 399                 m_animation = new QGraphicsItemAnimation;
 400                 m_animation->setItem(m_visualTip);
 401                 m_animation->setTimeLine(m_animationTimer);
 402                 m_visualTip->setPos(rect.x() + 10, rect.y() + rect.height() / 2 + 12);
 403                 double scale = 2.0;
 404                 m_animation->setScaleAt(.5, scale, scale);
 405                 scale = 1.0;
 406                 m_animation->setScaleAt(1, scale, scale);
 407                 scene()->addItem(m_visualTip);
 408                 m_animationTimer->start();
 409             }*/
 410             setCursor(Qt::PointingHandCursor);
 411         } else if (opMode == TRANSITIONEND) {
 412             /*if (m_visualTip == NULL) {
 413                 QRectF rect = clip->sceneBoundingRect();
 414                 m_visualTip = new QGraphicsEllipseItem(-5, -5 , 10, 10);
 415                 ((QGraphicsEllipseItem*) m_visualTip)->setBrush(m_tipColor);
 416                 ((QGraphicsEllipseItem*) m_visualTip)->setPen(m_tipPen);
 417                 m_visualTip->setZValue(100);
 418                 m_animation = new QGraphicsItemAnimation;
 419                 m_animation->setItem(m_visualTip);
 420                 m_animation->setTimeLine(m_animationTimer);
 421                 m_visualTip->setPos(rect.x() + rect.width() - 10 , rect.y() + rect.height() / 2 + 12);
 422                 double scale = 2.0;
 423                 m_animation->setScaleAt(.5, scale, scale);
 424                 scale = 1.0;
 425                 m_animation->setScaleAt(1, scale, scale);
 426                 scene()->addItem(m_visualTip);
 427                 m_animationTimer->start();
 428             }*/
 429             setCursor(Qt::PointingHandCursor);
 430         } else if (opMode == KEYFRAME) {
 431             setCursor(Qt::PointingHandCursor);
 432         }
 433     } // no clip under mouse
 434     else if (m_tool == RAZORTOOL) {
 435         event->accept();
 436         return;
 437     } else if (opMode == MOVEGUIDE) {
 438         m_moveOpMode = opMode;
 439         setCursor(Qt::SplitHCursor);
 440     } else {
 441         m_moveOpMode = NONE;
 442         if (event->buttons() != Qt::NoButton && event->modifiers() == Qt::NoModifier) {
 443             setCursorPos((int)(mapToScene(event->pos().x(), 0).x()));
 444         }
 445         if (m_visualTip) {
 446             if (m_animation) delete m_animation;
 447             m_animationTimer->stop();
 448             m_animation = NULL;
 449             delete m_visualTip;
 450             m_visualTip = NULL;
 451
 452         }
 453         setCursor(Qt::ArrowCursor);
 454     }
 455     QGraphicsView::mouseMoveEvent(event);
 456 }
 457
 458 // virtual
 459 void CustomTrackView::mousePressEvent(QMouseEvent * event) {
 460     m_menuPosition = QPoint();
 461     m_blockRefresh = true;
 462     bool collision = false;
 463
 464     if (m_tool != RAZORTOOL) activateMonitor();
 465     m_clickEvent = event->pos();
 466
 467     // special cases (middle click button or ctrl / shift click
 468     if (event->button() == Qt::MidButton) {
 469         m_document->renderer()->switchPlay();
 470         m_blockRefresh = false;
 471         return;
 472     }
 473
 474     // check item under mouse
 475     QList<QGraphicsItem *> collisionList = items(event->pos());
 476
 477     if (event->modifiers() == Qt::ControlModifier && collisionList.count() == 0) {
 478         setDragMode(QGraphicsView::ScrollHandDrag);
 479         QGraphicsView::mousePressEvent(event);
 480         m_blockRefresh = false;
 481         return;
 482     }
 483
 484     if (event->modifiers() == Qt::ShiftModifier && collisionList.count() == 0) {
 485         setDragMode(QGraphicsView::RubberBandDrag);
 486         QGraphicsView::mousePressEvent(event);
 487         m_blockRefresh = false;
 488         return;
 489     }
 490
 491     if (collisionList.count() == 1 && collisionList.at(0)->type() == GUIDEITEM) {
 492         // a guide item was pressed
 493         collisionList.at(0)->setFlag(QGraphicsItem::ItemIsMovable, true);
 494         m_dragItem = NULL;
 495         m_dragGuide = (Guide *) collisionList.at(0);
 496         collision = true;
 497         m_operationMode = MOVEGUIDE;
 498         // deselect all clips so that only the guide will move
 499         m_scene->clearSelection();
 500         if (m_selectionGroup) {
 501             scene()->destroyItemGroup(m_selectionGroup);
 502             m_selectionGroup = NULL;
 503         }
 504         updateSnapPoints(NULL);
 505         QGraphicsView::mousePressEvent(event);
 506         return;
 507     }
 508
 509     // Find first clip or transition under mouse
 510     int i = 0;
 511     m_dragItem = NULL;
 512     while (i < collisionList.count()) {
 513         if (collisionList.at(i)->type() == AVWIDGET || collisionList.at(i)->type() == TRANSITIONWIDGET) {
 514             m_dragItem = static_cast <AbstractClipItem *>(collisionList.at(i));
 515             m_dragItemInfo = m_dragItem->info();
 516             break;
 517         }
 518         i++;
 519     }
 520
 521     // context menu requested
 522     if (event->button() == Qt::RightButton) {
 523         if (m_dragItem) {
 524             if (!m_dragItem->isSelected()) {
 525                 m_scene->clearSelection();
 526                 if (m_selectionGroup) scene()->destroyItemGroup(m_selectionGroup);
 527                 m_dragItem->setSelected(true);
 528             }
 529         }
 530         m_operationMode = NONE;
 531         displayContextMenu(event->globalPos(), m_dragItem);
 532         m_menuPosition = event->pos();
 533         m_dragItem = NULL;
 534         event->accept();
 535         return;
 536     }
 537
 538     // No item under click
 539     if (m_dragItem == NULL) {
 540         if (m_selectionGroup) scene()->destroyItemGroup(m_selectionGroup);
 541         setCursor(Qt::ArrowCursor);
 542         m_scene->clearSelection();
 543         setCursorPos((int)(mapToScene(event->x(), 0).x()));
 544         event->accept();
 545         return;
 546     }
 547
 548     // Razor tool
 549     if (m_tool == RAZORTOOL) {
 550         if (m_dragItem->type() == TRANSITIONWIDGET) {
 551             emit displayMessage(i18n("Cannot cut a transition"), ErrorMessage);
 552             event->accept();
 553             m_dragItem = NULL;
 554             return;
 555         }
 556         AbstractClipItem *clip = static_cast <AbstractClipItem *>(m_dragItem);
 557         RazorClipCommand* command = new RazorClipCommand(this, clip->info(), GenTime((int)(mapToScene(event->pos()).x()), m_document->fps()), true);
 558         m_commandStack->push(command);
 559         m_document->setModified(true);
 560         m_dragItem = NULL;
 561         event->accept();
 562         return;
 563     }
 564     updateSnapPoints(m_dragItem);
 565     if (m_dragItem && m_dragItem->type() == AVWIDGET) emit clipItemSelected((ClipItem*) m_dragItem);
 566     else emit clipItemSelected(NULL);
 567
 568     if (m_operationMode == NONE) QGraphicsView::mousePressEvent(event);
 569
 570     if (m_selectionGroup) {
 571         // delete selection group
 572         scene()->destroyItemGroup(m_selectionGroup);
 573         m_selectionGroup = NULL;
 574     }
 575
 576     QList<QGraphicsItem *> selection = m_scene->selectedItems();
 577     if (selection.count() > 1) {
 578         m_selectionGroup = new AbstractGroupItem(m_document->fps());
 579         scene()->addItem(m_selectionGroup);
 580         for (int i = 0; i < selection.count(); i++) {
 581             if (selection.at(i)->type() == AVWIDGET)
 582                 m_selectionGroup->addItem(selection.at(i));
 583         }
 584     }
 585
 586     m_clickPoint = QPoint((int)(mapToScene(event->pos()).x() - m_dragItem->startPos().frames(m_document->fps())), (int)(event->pos().y() - m_dragItem->pos().y()));
 587     /*
 588                         if (!item->isSelected()) {
 589
 590                             if (event->modifiers() != Qt::ControlModifier) {
 591                                 QList<QGraphicsItem *> itemList = items();
 592                                 for (int i = 0; i < itemList.count(); i++) {
 593                                     itemList.at(i)->setSelected(false);
 594                                     itemList.at(i)->update();
 595                                 }
 596                             }
 597                             item->setSelected(true);
 598                             item->update();
 599                         }
 600
 601
 602
 603                         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()));
 604                         m_dragItemInfo.startPos = m_dragItem->startPos();
 605                         m_dragItemInfo.endPos = m_dragItem->endPos();
 606                         m_dragItemInfo.track = m_dragItem->track();
 607
 608                         m_selectedClipList.clear();
 609                         QList<QGraphicsItem *> selected = scene()->selectedItems();
 610                         for (int i = 0; i < selected.count(); i++) {
 611                             if (selected.at(i)->type() == AVWIDGET || selected.at(i)->type() == TRANSITIONWIDGET)
 612                                 m_selectedClipList.append(static_cast <AbstractClipItem *>(selected.at(i)));
 613                         }
 614           */
 615     m_operationMode = m_dragItem->operationMode(mapToScene(event->pos()));
 616
 617     if (m_operationMode == KEYFRAME) {
 618         m_dragItem->updateSelectedKeyFrame();
 619         m_blockRefresh = false;
 620         return;
 621     } else if (m_operationMode == MOVE) {
 622         setCursor(Qt::ClosedHandCursor);
 623     } else if (m_operationMode == TRANSITIONSTART) {
 624         ItemInfo info;
 625         info.startPos = m_dragItem->startPos();
 626         info.track = m_dragItem->track();
 627         int transitiontrack = getPreviousVideoTrack(info.track);
 628         ClipItem *transitionClip = NULL;
 629         if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.startPos.frames(m_document->fps()), m_scene->m_tracksList.count() - transitiontrack);
 630         if (transitionClip && transitionClip->endPos() < m_dragItem->endPos()) {
 631             info.endPos = transitionClip->endPos();
 632         } else info.endPos = info.startPos + GenTime(2.5);
 633
 634         slotAddTransition((ClipItem *) m_dragItem, info, transitiontrack);
 635     } else if (m_operationMode == TRANSITIONEND) {
 636         ItemInfo info;
 637         info.endPos = m_dragItem->endPos();
 638         info.track = m_dragItem->track();
 639         int transitiontrack = getPreviousVideoTrack(info.track);
 640         ClipItem *transitionClip = NULL;
 641         if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.endPos.frames(m_document->fps()), m_scene->m_tracksList.count() - transitiontrack);
 642         if (transitionClip && transitionClip->startPos() > m_dragItem->startPos()) {
 643             info.startPos = transitionClip->startPos();
 644         } else info.startPos = info.endPos - GenTime(2.5);
 645         slotAddTransition((ClipItem *) m_dragItem, info, transitiontrack);
 646     }
 647
 648     m_blockRefresh = false;
 649     //kDebug()<<pos;
 650     //QGraphicsView::mousePressEvent(event);
 651 }
 652
 653 void CustomTrackView::mouseDoubleClickEvent(QMouseEvent *event) {
 654     if (m_dragItem && m_dragItem->hasKeyFrames()) {
 655         if (m_moveOpMode == KEYFRAME) {
 656             // user double clicked on a keyframe, open edit dialog
 657             QDialog d(parentWidget());
 658             Ui::KeyFrameDialog_UI view;
 659             view.setupUi(&d);
 660             view.kfr_position->setText(m_document->timecode().getTimecode(GenTime(m_dragItem->selectedKeyFramePos(), m_document->fps()) - m_dragItem->cropStart(), m_document->fps()));
 661             view.kfr_value->setValue(m_dragItem->selectedKeyFrameValue());
 662             view.kfr_value->setFocus();
 663             if (d.exec() == QDialog::Accepted) {
 664                 int pos = m_document->timecode().getFrameCount(view.kfr_position->text(), m_document->fps());
 665                 m_dragItem->updateKeyFramePos(GenTime(pos, m_document->fps()) + m_dragItem->cropStart(), (double) view.kfr_value->value() * m_dragItem->keyFrameFactor());
 666                 ClipItem *item = (ClipItem *)m_dragItem;
 667                 QString previous = item->keyframes(item->selectedEffectIndex());
 668                 item->updateKeyframeEffect();
 669                 QString next = item->keyframes(item->selectedEffectIndex());
 670                 EditKeyFrameCommand *command = new EditKeyFrameCommand(this, item->track(), item->startPos(), item->selectedEffectIndex(), previous, next, false);
 671                 m_commandStack->push(command);
 672                 updateEffect(m_scene->m_tracksList.count() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
 673             }
 674
 675         } else  {
 676             // add keyframe
 677             GenTime keyFramePos = GenTime((int)(mapToScene(event->pos()).x()), m_document->fps()) - m_dragItem->startPos() + m_dragItem->cropStart();
 678             m_dragItem->addKeyFrame(keyFramePos, mapToScene(event->pos()).toPoint().y());
 679             ClipItem * item = (ClipItem *) m_dragItem;
 680             QString previous = item->keyframes(item->selectedEffectIndex());
 681             item->updateKeyframeEffect();
 682             QString next = item->keyframes(item->selectedEffectIndex());
 683             EditKeyFrameCommand *command = new EditKeyFrameCommand(this, m_dragItem->track(), m_dragItem->startPos(), item->selectedEffectIndex(), previous, next, false);
 684             m_commandStack->push(command);
 685             updateEffect(m_scene->m_tracksList.count() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
 686         }
 687     } else if (m_dragItem) {
 688         ClipDurationDialog d(m_dragItem, m_document->timecode(), this);
 689         if (d.exec() == QDialog::Accepted) {
 690             if (d.startPos() != m_dragItem->startPos()) {
 691                 if (m_dragItem->type() == AVWIDGET) {
 692                     ItemInfo startInfo;
 693                     startInfo.startPos = m_dragItem->startPos();
 694                     startInfo.endPos = m_dragItem->endPos();
 695                     startInfo.track = m_dragItem->track();
 696                     ItemInfo endInfo;
 697                     endInfo.startPos = d.startPos();
 698                     endInfo.endPos = m_dragItem->endPos() + (endInfo.startPos - startInfo.startPos);
 699                     endInfo.track = m_dragItem->track();
 700                     MoveClipCommand *command = new MoveClipCommand(this, startInfo, endInfo, true);
 701                     m_commandStack->push(command);
 702                 } else {
 703                     //TODO: move transition
 704                 }
 705             }
 706             if (d.duration() != m_dragItem->duration()) {
 707                 if (m_dragItem->type() == AVWIDGET) {
 708                     ItemInfo startInfo;
 709                     startInfo.startPos = m_dragItem->startPos();
 710                     startInfo.endPos = m_dragItem->endPos();
 711                     startInfo.track = m_dragItem->track();
 712                     ItemInfo endInfo;
 713                     endInfo.startPos = startInfo.startPos;
 714                     endInfo.endPos = endInfo.startPos + d.duration();
 715                     endInfo.track = m_dragItem->track();
 716                     ResizeClipCommand *command = new ResizeClipCommand(this, startInfo, endInfo, true);
 717                     m_commandStack->push(command);
 718                 } else {
 719                     //TODO: resize transition
 720                 }
 721             }
 722         }
 723     } else {
 724         QList<QGraphicsItem *> collisionList = items(event->pos());
 725         if (collisionList.count() == 1 && collisionList.at(0)->type() == GUIDEITEM) {
 726             Guide *editGuide = (Guide *) collisionList.at(0);
 727             if (editGuide) slotEditGuide(editGuide->info());
 728         }
 729     }
 730 }
 731
 732
 733 void CustomTrackView::editKeyFrame(const GenTime pos, const int track, const int index, const QString keyframes) {
 734     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()), track);
 735     if (clip) {
 736         clip->setKeyframes(index, keyframes);
 737         updateEffect(m_scene->m_tracksList.count() - clip->track(), clip->startPos(), clip->effectAt(index), index);
 738     } else emit displayMessage(i18n("Cannot find clip with keyframe"), ErrorMessage);
 739 }
 740
 741
 742 void CustomTrackView::displayContextMenu(QPoint pos, AbstractClipItem *clip) {
 743     if (clip == NULL) m_timelineContextMenu->popup(pos);
 744     else if (clip->type() == AVWIDGET) m_timelineContextClipMenu->popup(pos);
 745     else if (clip->type() == TRANSITIONWIDGET) m_timelineContextTransitionMenu->popup(pos);
 746 }
 747
 748 void CustomTrackView::activateMonitor() {
 749     emit activateDocumentMonitor();
 750 }
 751
 752 void CustomTrackView::dragEnterEvent(QDragEnterEvent * event) {
 753     if (event->mimeData()->hasFormat("kdenlive/producerslist")) {
 754         kDebug() << "///////////////  DRAG ENTERED, TEXT: " << event->mimeData()->data("kdenlive/producerslist");
 755         QStringList ids = QString(event->mimeData()->data("kdenlive/producerslist")).split(";");
 756         //TODO: drop of several clips
 757         for (int i = 0; i < ids.size(); ++i) {
 758         }
 759         DocClipBase *clip = m_document->getBaseClip(ids.at(0));
 760         if (clip == NULL) kDebug() << " WARNING))))))))) CLIP NOT FOUND : " << ids.at(0);
 761         addItem(clip, event->pos());
 762         event->acceptProposedAction();
 763     } else QGraphicsView::dragEnterEvent(event);
 764 }
 765
 766 void CustomTrackView::slotRefreshEffects(ClipItem *clip) {
 767     int track = m_scene->m_tracksList.count() - clip->track();
 768     GenTime pos = clip->startPos();
 769     if (!m_document->renderer()->mltRemoveEffect(track, pos, "-1", false)) {
 770         emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
 771         return;
 772     }
 773     bool success = true;
 774     for (int i = 0; i < clip->effectsCount(); i++) {
 775         if (!m_document->renderer()->mltAddEffect(track, pos, clip->getEffectArgs(clip->effectAt(i)), false)) success = false;
 776     }
 777     if (!success) emit displayMessage(i18n("Problem adding effect to clip"), ErrorMessage);
 778     m_document->renderer()->doRefresh();
 779 }
 780
 781 void CustomTrackView::addEffect(int track, GenTime pos, QDomElement effect) {
 782     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_scene->m_tracksList.count() - track);
 783     if (clip) {
 784         QHash <QString, QString> effectParams = clip->addEffect(effect);
 785         if (!m_document->renderer()->mltAddEffect(track, pos, effectParams))
 786             emit displayMessage(i18n("Problem adding effect to clip"), ErrorMessage);
 787         emit clipItemSelected(clip);
 788     } else emit displayMessage(i18n("Cannot find clip to add effect"), ErrorMessage);
 789 }
 790
 791 void CustomTrackView::deleteEffect(int track, GenTime pos, QDomElement effect) {
 792     QString index = effect.attribute("kdenlive_ix");
 793     if (effect.attribute("disabled") != "1" && !m_document->renderer()->mltRemoveEffect(track, pos, index)) {
 794         emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
 795         return;
 796     }
 797     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_scene->m_tracksList.count() - track);
 798     if (clip) {
 799         clip->deleteEffect(index);
 800         emit clipItemSelected(clip);
 801     }
 802 }
 803
 804 void CustomTrackView::slotAddEffect(QDomElement effect, GenTime pos, int track) {
 805     QList<QGraphicsItem *> itemList;
 806     if (track == -1) itemList = scene()->selectedItems();
 807     if (itemList.isEmpty()) {
 808         ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, track);
 809         if (clip) itemList.append(clip);
 810         else emit displayMessage(i18n("Select a clip if you want to apply an effect"), ErrorMessage);
 811     }
 812     kDebug() << "// REQUESTING EFFECT ON CLIP: " << pos.frames(25) << ", TRK: " << track << "SELECTED ITEMS: " << itemList.count();
 813     for (int i = 0; i < itemList.count(); i++) {
 814         if (itemList.at(i)->type() == AVWIDGET) {
 815             ClipItem *item = (ClipItem *)itemList.at(i);
 816             item->initEffect(effect);
 817             AddEffectCommand *command = new AddEffectCommand(this, m_scene->m_tracksList.count() - item->track(), item->startPos(), effect, true);
 818             m_commandStack->push(command);
 819         }
 820     }
 821     m_document->setModified(true);
 822 }
 823
 824 void CustomTrackView::slotDeleteEffect(ClipItem *clip, QDomElement effect) {
 825     AddEffectCommand *command = new AddEffectCommand(this, m_scene->m_tracksList.count() - clip->track(), clip->startPos(), effect, false);
 826     m_commandStack->push(command);
 827     m_document->setModified(true);
 828 }
 829
 830 void CustomTrackView::updateEffect(int track, GenTime pos, QDomElement effect, int ix) {
 831     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_scene->m_tracksList.count() - track);
 832     if (clip) {
 833         QHash <QString, QString> effectParams = clip->getEffectArgs(effect);
 834         if (effectParams.value("disabled") == "1") {
 835             if (m_document->renderer()->mltRemoveEffect(track, pos, effectParams.value("kdenlive_ix"))) {
 836                 kDebug() << "//////  DISABLING EFFECT: " << index << ", CURRENTLA: " << clip->selectedEffectIndex();
 837             } else emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
 838         } else if (!m_document->renderer()->mltEditEffect(m_scene->m_tracksList.count() - clip->track(), clip->startPos(), effectParams))
 839             emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
 840         if (ix == clip->selectedEffectIndex()) {
 841             clip->setSelectedEffect(clip->selectedEffectIndex());
 842         }
 843     }
 844     m_document->setModified(true);
 845 }
 846
 847 void CustomTrackView::moveEffect(int track, GenTime pos, int oldPos, int newPos) {
 848     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_scene->m_tracksList.count() - track);
 849     if (clip) {
 850         m_document->renderer()->mltMoveEffect(track, pos, oldPos, newPos);
 851     }
 852     m_document->setModified(true);
 853 }
 854
 855 void CustomTrackView::slotChangeEffectState(ClipItem *clip, int effectPos, bool disable) {
 856     QDomElement effect = clip->effectAt(effectPos);
 857     QDomElement oldEffect = effect.cloneNode().toElement();
 858     effect.setAttribute("disabled", disable);
 859     EditEffectCommand *command = new EditEffectCommand(this, m_scene->m_tracksList.count() - clip->track(), clip->startPos(), oldEffect, effect, effectPos, true);
 860     m_commandStack->push(command);
 861     m_document->setModified(true);
 862 }
 863
 864 void CustomTrackView::slotChangeEffectPosition(ClipItem *clip, int currentPos, int newPos) {
 865     MoveEffectCommand *command = new MoveEffectCommand(this, m_scene->m_tracksList.count() - clip->track(), clip->startPos(), currentPos, newPos, true);
 866     m_commandStack->push(command);
 867     m_document->setModified(true);
 868 }
 869
 870 void CustomTrackView::slotUpdateClipEffect(ClipItem *clip, QDomElement oldeffect, QDomElement effect, int ix) {
 871     EditEffectCommand *command = new EditEffectCommand(this, m_scene->m_tracksList.count() - clip->track(), clip->startPos(), oldeffect, effect, ix, true);
 872     m_commandStack->push(command);
 873 }
 874
 875 void CustomTrackView::cutClip(ItemInfo info, GenTime cutTime, bool cut) {
 876     if (cut) {
 877         // cut clip
 878         ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
 879         if (!item || cutTime >= item->endPos() || cutTime <= item->startPos()) {
 880             emit displayMessage(i18n("Cannot find clip to cut"), ErrorMessage);
 881             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);
 882             m_blockRefresh = false;
 883             return;
 884         }
 885         kDebug() << "/////////  CUTTING CLIP : (" << item->startPos().frames(25) << "-" << item->endPos().frames(25) << "), INFO: (" << info.startPos.frames(25) << "-" << info.endPos.frames(25) << ")" << ", CUT: " << cutTime.frames(25);
 886
 887         m_document->renderer()->mltCutClip(m_scene->m_tracksList.count() - info.track, cutTime);
 888         int cutPos = (int) cutTime.frames(m_document->fps());
 889         ItemInfo newPos;
 890         newPos.startPos = cutTime;
 891         newPos.endPos = info.endPos;
 892         newPos.cropStart = item->cropStart() + (cutTime - info.startPos);
 893         newPos.track = info.track;
 894         ClipItem *dup = item->clone(newPos);
 895         kDebug() << "// REsizing item to: " << cutPos;
 896         item->resizeEnd(cutPos);
 897         scene()->addItem(dup);
 898         item->baseClip()->addReference();
 899         m_document->updateClip(item->baseClip()->getId());
 900         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);
 901         kDebug() << "//  CUTTING CLIP dONE";
 902     } else {
 903         // uncut clip
 904
 905         ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
 906         ClipItem *dup = getClipItemAt((int) cutTime.frames(m_document->fps()) + 1, info.track);
 907         if (!item || !dup || item == dup) {
 908             emit displayMessage(i18n("Cannot find clip to uncut"), ErrorMessage);
 909             m_blockRefresh = false;
 910             return;
 911         }
 912
 913         kDebug() << "// UNCUTTING CLIPS: ITEM 1 (" << item->startPos().frames(25) << "x" << item->endPos().frames(25) << ")";
 914         kDebug() << "// UNCUTTING CLIPS: ITEM 2 (" << dup->startPos().frames(25) << "x" << dup->endPos().frames(25) << ")";
 915         kDebug() << "// UNCUTTING CLIPS, INFO (" << info.startPos.frames(25) << "x" << info.endPos.frames(25) << ") , CUT: " << cutTime.frames(25);;
 916         //deleteClip(dup->info());
 917
 918
 919         if (dup->isSelected()) emit clipItemSelected(NULL);
 920         dup->baseClip()->removeReference();
 921         m_document->updateClip(dup->baseClip()->getId());
 922         scene()->removeItem(dup);
 923         delete dup;
 924         m_document->renderer()->mltRemoveClip(m_scene->m_tracksList.count() - info.track, cutTime);
 925
 926         ItemInfo clipinfo = item->info();
 927         clipinfo.track = m_scene->m_tracksList.count() - clipinfo.track;
 928         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, info.endPos - info.startPos);
 929         if (success) {
 930             item->resizeEnd((int) info.endPos.frames(m_document->fps()));
 931         } else
 932             emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
 933
 934     }
 935     QTimer::singleShot(3000, this, SLOT(slotEnableRefresh()));
 936 }
 937
 938 void CustomTrackView::slotEnableRefresh() {
 939     m_blockRefresh = false;
 940 }
 941
 942 void CustomTrackView::slotAddTransitionToSelectedClips(QDomElement transition) {
 943     QList<QGraphicsItem *> itemList = scene()->selectedItems();
 944     for (int i = 0; i < itemList.count(); i++) {
 945         if (itemList.at(i)->type() == AVWIDGET) {
 946             ClipItem *item = (ClipItem *) itemList.at(i);
 947             ItemInfo info;
 948             info.startPos = item->startPos();
 949             info.endPos = info.startPos + GenTime(2.5);
 950             info.track = item->track();
 951             int transitiontrack = getPreviousVideoTrack(info.track);
 952             slotAddTransition(item, info, transitiontrack, transition);
 953         }
 954     }
 955 }
 956
 957 void CustomTrackView::slotAddTransition(ClipItem* clip, ItemInfo transitionInfo, int endTrack, QDomElement transition) {
 958     AddTransitionCommand* command = new AddTransitionCommand(this, transitionInfo, endTrack, transition, false, true);
 959     m_commandStack->push(command);
 960     m_document->setModified(true);
 961 }
 962
 963 void CustomTrackView::addTransition(ItemInfo transitionInfo, int endTrack, QDomElement params) {
 964     Transition *tr = new Transition(transitionInfo, endTrack, m_document->fps(), params);
 965     scene()->addItem(tr);
 966
 967     //kDebug() << "---- ADDING transition " << e.attribute("tag") << ", on tracks " << m_scene->m_tracksList.count() - e.attribute("transition_track").toInt() << " / " << getPreviousVideoTrack(e.attribute("transition_track").toInt());
 968     m_document->renderer()->mltAddTransition(tr->transitionTag(), endTrack, m_scene->m_tracksList.count() - transitionInfo.track, transitionInfo.startPos, transitionInfo.endPos, tr->toXML());
 969     m_document->setModified(true);
 970 }
 971
 972 void CustomTrackView::deleteTransition(ItemInfo transitionInfo, int endTrack, QDomElement params) {
 973     Transition *item = getTransitionItemAt((int)transitionInfo.startPos.frames(m_document->fps()) + 1, transitionInfo.track);
 974     m_document->renderer()->mltDeleteTransition(item->transitionTag(), endTrack, m_scene->m_tracksList.count() - transitionInfo.track, transitionInfo.startPos, transitionInfo.endPos, item->toXML());
 975     delete item;
 976     emit transitionItemSelected(NULL);
 977     m_document->setModified(true);
 978 }
 979
 980 void CustomTrackView::slotTransitionUpdated(Transition *tr, QDomElement old) {
 981     EditTransitionCommand *command = new EditTransitionCommand(this, tr->track(), tr->startPos(), old, tr->toXML() , true);
 982     m_commandStack->push(command);
 983     m_document->setModified(true);
 984 }
 985
 986 void CustomTrackView::updateTransition(int track, GenTime pos, QDomElement oldTransition, QDomElement transition) {
 987     Transition *item = getTransitionItemAt((int)pos.frames(m_document->fps()) + 1, track);
 988     if (!item) {
 989         kWarning() << "Unable to find transition at pos :" << pos.frames(m_document->fps()) << ", ON track: " << track;
 990         return;
 991     }
 992     m_document->renderer()->mltUpdateTransition(oldTransition.attribute("tag"), transition.attribute("tag"), transition.attribute("transition_btrack").toInt(), m_scene->m_tracksList.count() - transition.attribute("transition_atrack").toInt(), item->startPos(), item->endPos(), transition);
 993     item->setTransitionParameters(transition);
 994     m_document->setModified(true);
 995 }
 996
 997 void CustomTrackView::addItem(DocClipBase *clip, QPoint pos) {
 998     ItemInfo info;
 999     info.startPos = GenTime((int)(mapToScene(pos).x()), m_document->fps());
1000     info.endPos = info.startPos + clip->duration();
1001     info.track = (int)(pos.y() / m_tracksHeight);
1002     kDebug() << "------------  ADDING CLIP ITEM----: " << info.startPos.frames(25) << ", " << info.endPos.frames(25) << ", " << info.track;
1003     m_dropItem = new ClipItem(clip, info, m_document->fps());
1004     scene()->addItem(m_dropItem);
1005 }
1006
1007
1008 void CustomTrackView::dragMoveEvent(QDragMoveEvent * event) {
1009     event->setDropAction(Qt::IgnoreAction);
1010     if (m_dropItem) {
1011         int track = (int)(mapToScene(event->pos()).y() / m_tracksHeight);
1012         int pos = mapToScene(event->pos()).x();
1013         m_dropItem->setPos(pos, track * m_tracksHeight + 1);
1014         event->setDropAction(Qt::MoveAction);
1015         if (event->mimeData()->hasFormat("kdenlive/producerslist")) {
1016             event->acceptProposedAction();
1017         }
1018     } else {
1019         QGraphicsView::dragMoveEvent(event);
1020     }
1021 }
1022
1023 void CustomTrackView::dragLeaveEvent(QDragLeaveEvent * event) {
1024     if (m_dropItem) {
1025         delete m_dropItem;
1026         m_dropItem = NULL;
1027     } else QGraphicsView::dragLeaveEvent(event);
1028 }
1029
1030 void CustomTrackView::dropEvent(QDropEvent * event) {
1031     if (m_dropItem) {
1032         AddTimelineClipCommand *command = new AddTimelineClipCommand(this, m_dropItem->xml(), m_dropItem->clipProducer(), m_dropItem->info(), m_dropItem->effectList(), false, false);
1033         m_commandStack->push(command);
1034         //((ClipItem *) m_dropItem)->refreshClip();
1035         m_dropItem->baseClip()->addReference();
1036         m_document->updateClip(m_dropItem->baseClip()->getId());
1037         ItemInfo info;
1038         info = m_dropItem->info();
1039         info.track = m_scene->m_tracksList.count() - m_dropItem->track();
1040         //kDebug()<<"IIIIIIIIIIIIIIIIIIIIIIII TRAX CNT: "<<m_scene->m_tracksList.count()<<", DROP: "<<m_dropItem->track();
1041         m_document->renderer()->mltInsertClip(info, m_dropItem->xml(), m_dropItem->baseClip()->producer());
1042         //if (m_dropItem->baseClip()->isTransparent()) m_document->renderer()->mltAddClipTransparency(info, getPreviousVideoTrack(m_dropItem->track()), m_dropItem->baseClip()->getId());
1043         m_dropItem = NULL;
1044         m_document->setModified(true);
1045     } else QGraphicsView::dropEvent(event);
1046     m_dropItem = NULL;
1047 }
1048
1049
1050 QStringList CustomTrackView::mimeTypes() const {
1051     QStringList qstrList;
1052     // list of accepted mime types for drop
1053     qstrList.append("text/plain");
1054     qstrList.append("kdenlive/producerslist");
1055     return qstrList;
1056 }
1057
1058 Qt::DropActions CustomTrackView::supportedDropActions() const {
1059     // returns what actions are supported when dropping
1060     return Qt::MoveAction;
1061 }
1062
1063 void CustomTrackView::setDuration(int duration) {
1064     kDebug() << "/////////////  PRO DUR: " << duration << ", SCALE. " << (m_projectDuration + 500) << ", height: " << 50 * m_scene->m_tracksList.count();
1065     m_projectDuration = duration;
1066     setSceneRect(0, 0, (m_projectDuration + 100), sceneRect().height());
1067 }
1068
1069 int CustomTrackView::duration() const {
1070     return m_projectDuration;
1071 }
1072
1073 void CustomTrackView::addTrack(TrackInfo type) {
1074     m_scene->m_tracksList << type;
1075     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), m_tracksHeight * m_scene->m_tracksList.count());
1076     setSceneRect(0, 0, sceneRect().width(), m_tracksHeight * m_scene->m_tracksList.count());
1077     verticalScrollBar()->setMaximum(m_tracksHeight * m_scene->m_tracksList.count());
1078     //setFixedHeight(50 * m_tracksCount);
1079 }
1080
1081 void CustomTrackView::removeTrack() {
1082     // TODO: implement track deletion
1083     //m_tracksCount--;
1084     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), m_tracksHeight * m_scene->m_tracksList.count());
1085 }
1086
1087
1088 void CustomTrackView::slotSwitchTrackAudio(int ix) {
1089     int tracknumber = m_scene->m_tracksList.count() - ix;
1090     kDebug() << "/////  MUTING TRK: " << ix << "; PL NUM: " << tracknumber;
1091     m_scene->m_tracksList[tracknumber - 1].isMute = !m_scene->m_tracksList.at(tracknumber - 1).isMute;
1092     m_document->renderer()->mltChangeTrackState(tracknumber, m_scene->m_tracksList.at(tracknumber - 1).isMute, m_scene->m_tracksList.at(tracknumber - 1).isBlind);
1093 }
1094
1095 void CustomTrackView::slotSwitchTrackVideo(int ix) {
1096     int tracknumber = m_scene->m_tracksList.count() - ix;
1097     m_scene->m_tracksList[tracknumber - 1].isBlind = !m_scene->m_tracksList.at(tracknumber - 1).isBlind;
1098     m_document->renderer()->mltChangeTrackState(tracknumber, m_scene->m_tracksList.at(tracknumber - 1).isMute, m_scene->m_tracksList.at(tracknumber - 1).isBlind);
1099 }
1100
1101 void CustomTrackView::deleteClip(const QString &clipId) {
1102     QList<QGraphicsItem *> itemList = items();
1103     for (int i = 0; i < itemList.count(); i++) {
1104         if (itemList.at(i)->type() == AVWIDGET) {
1105             ClipItem *item = (ClipItem *)itemList.at(i);
1106             if (item->clipProducer() == clipId) {
1107                 AddTimelineClipCommand *command = new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true);
1108                 m_commandStack->push(command);
1109                 //delete item;
1110             }
1111         }
1112     }
1113 }
1114
1115 void CustomTrackView::setCursorPos(int pos, bool seek) {
1116     emit cursorMoved((int)(m_cursorPos), (int)(pos));
1117     m_cursorPos = pos;
1118     m_cursorLine->setPos(pos, 0);
1119     if (seek) m_document->renderer()->seek(GenTime(pos, m_document->fps()));
1120     else if (m_autoScroll) checkScrolling();
1121 }
1122
1123 void CustomTrackView::updateCursorPos() {
1124     m_cursorLine->setPos(m_cursorPos, 0);
1125 }
1126
1127 int CustomTrackView::cursorPos() {
1128     return (int)(m_cursorPos);
1129 }
1130
1131 void CustomTrackView::moveCursorPos(int delta) {
1132     if (m_cursorPos + delta < 0) delta = 0 - m_cursorPos;
1133     emit cursorMoved((int)(m_cursorPos), (int)((m_cursorPos + delta)));
1134     m_cursorPos += delta;
1135     m_cursorLine->setPos(m_cursorPos, 0);
1136     m_document->renderer()->seek(GenTime(m_cursorPos, m_document->fps()));
1137     //if (m_autoScroll && m_scale < 50) checkScrolling();
1138 }
1139
1140 void CustomTrackView::checkScrolling() {
1141     int vert = verticalScrollBar()->value();
1142     int hor = cursorPos();
1143     ensureVisible(hor, vert + 10, 2, 2, 50, 0);
1144     //centerOn(QPointF(cursorPos(), m_tracksHeight));
1145     /*QRect rectInView = viewport()->rect();
1146     int delta = rectInView.width() / 3;
1147     int max = rectInView.right() + horizontalScrollBar()->value() - delta;
1148     //kDebug() << "CURSOR POS: "<<m_cursorPos<< "Scale: "<<m_scale;
1149     if (m_cursorPos * m_scale >= max) horizontalScrollBar()->setValue((int)(horizontalScrollBar()->value() + 1 + m_scale));*/
1150 }
1151
1152 void CustomTrackView::mouseReleaseEvent(QMouseEvent * event) {
1153     QGraphicsView::mouseReleaseEvent(event);
1154     if (event->button() == Qt::MidButton) {
1155         return;
1156     }
1157     setDragMode(QGraphicsView::NoDrag);
1158     if (m_operationMode == MOVEGUIDE) {
1159         setCursor(Qt::ArrowCursor);
1160         m_operationMode = NONE;
1161         m_dragGuide->setFlag(QGraphicsItem::ItemIsMovable, false);
1162         EditGuideCommand *command = new EditGuideCommand(this, m_dragGuide->position(), m_dragGuide->label(), GenTime(m_dragGuide->pos().x(), m_document->fps()), m_dragGuide->label(), false);
1163         m_commandStack->push(command);
1164         m_dragGuide->updateGuide(GenTime(m_dragGuide->pos().x(), m_document->fps()));
1165         m_dragGuide = NULL;
1166         m_dragItem = NULL;
1167         return;
1168     }
1169     if (m_dragItem == NULL) {
1170         emit transitionItemSelected(NULL);
1171         return;
1172     }
1173     ItemInfo info = m_dragItem->info();
1174
1175     if (m_operationMode == MOVE) {
1176         setCursor(Qt::OpenHandCursor);
1177
1178         if (m_selectionGroup == NULL) {
1179             // we are moving one clip, easy
1180             if (m_dragItem->type() == AVWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
1181                 bool success = m_document->renderer()->mltMoveClip((int)(m_scene->m_tracksList.count() - m_dragItemInfo.track), (int)(m_scene->m_tracksList.count() - m_dragItem->track()), (int) m_dragItemInfo.startPos.frames(m_document->fps()), (int)(m_dragItem->startPos().frames(m_document->fps())));
1182                 if (success) {
1183                     MoveClipCommand *command = new MoveClipCommand(this, m_dragItemInfo, info, false);
1184                     m_commandStack->push(command);
1185                 } else {
1186                     // undo last move and emit error message
1187                     MoveClipCommand *command = new MoveClipCommand(this, info, m_dragItemInfo, true);
1188                     m_commandStack->push(command);
1189                     emit displayMessage(i18n("Cannot move clip to position %1seconds", QString::number(m_dragItemInfo.startPos.seconds(), 'g', 2)), ErrorMessage);
1190                 }
1191             }
1192             if (m_dragItem->type() == TRANSITIONWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
1193                 MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
1194                 m_commandStack->push(command);
1195                 Transition *transition = (Transition *) m_dragItem;
1196                 transition->updateTransitionEndTrack(getPreviousVideoTrack(m_dragItem->track()));
1197                 m_document->renderer()->mltMoveTransition(transition->transitionTag(), (int)(m_scene->m_tracksList.count() - m_dragItemInfo.track), (int)(m_scene->m_tracksList.count() - m_dragItem->track()), transition->transitionEndTrack(), m_dragItemInfo.startPos, m_dragItemInfo.endPos, info.startPos, info.endPos);
1198             }
1199         } else {
1200             // Moving several clips. We need to delete them and readd them to new position,
1201             // or they might overlap each other during the move
1202
1203             GenTime timeOffset = info.startPos - m_dragItemInfo.startPos;
1204             int trackOffset = info.track - m_dragItemInfo.track;
1205             if (timeOffset != GenTime() || trackOffset != 0) {
1206                 QUndoCommand *moveClips = new QUndoCommand();
1207                 moveClips->setText("Move clips");
1208                 // remove items in MLT playlist
1209                 for (int i = 0; i < m_selectedClipList.count(); i++) {
1210                     AbstractClipItem *item = m_selectedClipList.at(i);
1211                     ItemInfo info = item->info();
1212                     info.startPos = info.startPos - timeOffset;
1213                     info.endPos = info.endPos - timeOffset;
1214                     info.track = info.track - trackOffset;
1215                     if (item->type() == AVWIDGET) {
1216                         ClipItem *clip = static_cast <ClipItem*>(item);
1217                         new AddTimelineClipCommand(this, clip->xml(), clip->clipProducer(), info, clip->effectList(), false, true, moveClips);
1218                         m_document->renderer()->mltRemoveClip(m_scene->m_tracksList.count() - info.track, info.startPos);
1219                     } else {
1220                         Transition *tr = static_cast <Transition*>(item);
1221                         new AddTransitionCommand(this, info, tr->transitionEndTrack(), tr->toXML(), false, true, moveClips);
1222                         m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_scene->m_tracksList.count() - info.track, info.startPos, info.endPos, tr->toXML());
1223                     }
1224                 }
1225
1226                 for (int i = 0; i < m_selectedClipList.count(); i++) {
1227                     // re-add items in correct place
1228                     AbstractClipItem *item = m_selectedClipList.at(i);
1229                     if (item->type() == AVWIDGET) {
1230                         ClipItem *clip = static_cast <ClipItem*>(item);
1231                         new AddTimelineClipCommand(this, clip->xml(), clip->clipProducer(), item->info(), clip->effectList(), false, false, moveClips);
1232                         ItemInfo info = item->info();
1233                         info.track = m_scene->m_tracksList.count() - item->track();
1234                         m_document->renderer()->mltInsertClip(info, clip->xml(), clip->baseClip()->producer());
1235                     } else {
1236                         Transition *tr = static_cast <Transition*>(item);
1237                         ItemInfo transitionInfo = tr->info();
1238                         new AddTransitionCommand(this, info, tr->transitionEndTrack(), tr->toXML(), false, false, moveClips);
1239                         m_document->renderer()->mltAddTransition(tr->transitionTag(), tr->transitionEndTrack() + trackOffset, m_scene->m_tracksList.count() - transitionInfo.track, transitionInfo.startPos, transitionInfo.endPos, tr->toXML());
1240                     }
1241                 }
1242                 m_commandStack->push(moveClips);
1243             }
1244         }
1245
1246     } else if (m_operationMode == RESIZESTART && m_dragItem->startPos() != m_dragItemInfo.startPos) {
1247         // resize start
1248         if (m_dragItem->type() == AVWIDGET) {
1249             ItemInfo resizeinfo = m_dragItemInfo;
1250             resizeinfo.track = m_scene->m_tracksList.count() - resizeinfo.track;
1251             bool success = m_document->renderer()->mltResizeClipStart(resizeinfo, m_dragItem->startPos() - m_dragItemInfo.startPos);
1252             if (success) {
1253                 updateClipFade((ClipItem *) m_dragItem);
1254                 ResizeClipCommand *command = new ResizeClipCommand(this, m_dragItemInfo, info, false);
1255                 m_commandStack->push(command);
1256             } else {
1257                 m_dragItem->resizeStart((int) m_dragItemInfo.startPos.frames(m_document->fps()));
1258                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
1259             }
1260         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
1261             MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
1262             m_commandStack->push(command);
1263             Transition *transition = (Transition *) m_dragItem;
1264             m_document->renderer()->mltMoveTransition(transition->transitionTag(), (int)(m_scene->m_tracksList.count() - m_dragItemInfo.track), (int)(m_scene->m_tracksList.count() - m_dragItemInfo.track), 0, m_dragItemInfo.startPos, m_dragItemInfo.endPos, info.startPos, info.endPos);
1265         }
1266
1267         //m_document->renderer()->doRefresh();
1268     } else if (m_operationMode == RESIZEEND && m_dragItem->endPos() != m_dragItemInfo.endPos) {
1269         // resize end
1270         if (m_dragItem->type() == AVWIDGET) {
1271             ItemInfo resizeinfo = info;
1272             resizeinfo.track = m_scene->m_tracksList.count() - resizeinfo.track;
1273             bool success = m_document->renderer()->mltResizeClipEnd(resizeinfo, resizeinfo.endPos - resizeinfo.startPos);
1274             if (success) {
1275                 ResizeClipCommand *command = new ResizeClipCommand(this, m_dragItemInfo, info, false);
1276                 m_commandStack->push(command);
1277             } else {
1278                 m_dragItem->resizeEnd((int) m_dragItemInfo.endPos.frames(m_document->fps()));
1279                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
1280             }
1281         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
1282             MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
1283             m_commandStack->push(command);
1284             Transition *transition = (Transition *) m_dragItem;
1285 //             m_document->renderer()->mltMoveTransition(transition->transitionTag(), (int)(m_scene->m_tracksList.count() - m_dragItemInfo.track), (int)(m_scene->m_tracksList.count() - m_dragItemInfo.track), 0, m_dragItemInfo.startPos, m_dragItemInfo.endPos, info.startPos, info.endPos);
1286         }
1287         //m_document->renderer()->doRefresh();
1288     } else if (m_operationMode == FADEIN) {
1289         // resize fade in effect
1290         ClipItem * item = (ClipItem *) m_dragItem;
1291         QStringList clipeffects = item->effectNames();
1292         if (clipeffects.contains(i18n("Fade in"))) {
1293             int ix = clipeffects.indexOf(i18n("Fade in"));
1294             QDomElement oldeffect = item->effectAt(ix);
1295             int start = item->cropStart().frames(m_document->fps());
1296             int end = item->fadeIn();
1297             if (end == 0) {
1298                 slotDeleteEffect(item, oldeffect);
1299             } else {
1300                 end += start;
1301                 QDomElement effect = MainWindow::audioEffects.getEffectByName("Fade in");
1302                 EffectsList::setParameter(effect, "in", QString::number(start));
1303                 EffectsList::setParameter(effect, "out", QString::number(end));
1304                 slotUpdateClipEffect(item, oldeffect, effect, ix);
1305             }
1306         } else if (item->fadeIn() != 0) {
1307             QDomElement effect = MainWindow::audioEffects.getEffectByName("Fade in");
1308             int start = item->cropStart().frames(m_document->fps());
1309             int end = item->fadeIn() + start;
1310             EffectsList::setParameter(effect, "in", QString::number(start));
1311             EffectsList::setParameter(effect, "out", QString::number(end));
1312             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
1313         }
1314     } else if (m_operationMode == FADEOUT) {
1315         // resize fade in effect
1316         ClipItem * item = (ClipItem *) m_dragItem;
1317         QStringList clipeffects = item->effectNames();
1318         if (clipeffects.contains(i18n("Fade out"))) {
1319             int ix = clipeffects.indexOf(i18n("Fade out"));
1320             QDomElement oldeffect = item->effectAt(ix);
1321             int end = (item->duration() + item->cropStart()).frames(m_document->fps());
1322             int start = item->fadeOut();
1323             if (start == 0) {
1324                 slotDeleteEffect(item, oldeffect);
1325             } else {
1326                 start = end - start;
1327                 QDomElement effect = MainWindow::audioEffects.getEffectByName("Fade out");
1328                 EffectsList::setParameter(effect, "in", QString::number(start));
1329                 EffectsList::setParameter(effect, "out", QString::number(end));
1330                 slotUpdateClipEffect(item, oldeffect, effect, ix);
1331             }
1332         } else if (item->fadeOut() != 0) {
1333             QDomElement effect = MainWindow::audioEffects.getEffectByName("Fade out");
1334             int end = (item->duration() + item->cropStart()).frames(m_document->fps());
1335             int start = end - item->fadeOut();
1336             EffectsList::setParameter(effect, "in", QString::number(start));
1337             EffectsList::setParameter(effect, "out", QString::number(end));
1338             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
1339         }
1340     } else if (m_operationMode == KEYFRAME) {
1341         // update the MLT effect
1342         ClipItem * item = (ClipItem *) m_dragItem;
1343         QString previous = item->keyframes(item->selectedEffectIndex());
1344         item->updateKeyframeEffect();
1345         QString next = item->keyframes(item->selectedEffectIndex());
1346         EditKeyFrameCommand *command = new EditKeyFrameCommand(this, item->track(), item->startPos(), item->selectedEffectIndex(), previous, next, false);
1347         m_commandStack->push(command);
1348         updateEffect(m_scene->m_tracksList.count() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
1349     }
1350
1351     emit transitionItemSelected((m_dragItem && m_dragItem->type() == TRANSITIONWIDGET) ? (Transition*) m_dragItem : NULL);
1352     m_document->setModified(true);
1353     m_operationMode = NONE;
1354 }
1355
1356 void CustomTrackView::deleteClip(ItemInfo info) {
1357     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
1358     if (!item) {
1359         kDebug() << "----------------  ERROR, CANNOT find clip to delete at...";// << rect.x();
1360         return;
1361     }
1362     if (item->isSelected()) emit clipItemSelected(NULL);
1363     item->baseClip()->removeReference();
1364     m_document->updateClip(item->baseClip()->getId());
1365     scene()->removeItem(item);
1366     delete item;
1367     m_document->renderer()->mltRemoveClip(m_scene->m_tracksList.count() - info.track, info.startPos);
1368     m_document->renderer()->doRefresh();
1369 }
1370
1371 void CustomTrackView::deleteSelectedClips() {
1372     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1373     if (itemList.count() == 0) {
1374         emit displayMessage(i18n("Select clip to delete"), ErrorMessage);
1375         return;
1376     }
1377     QUndoCommand *deleteSelected = new QUndoCommand();
1378     deleteSelected->setText("Delete selected items");
1379     for (int i = 0; i < itemList.count(); i++) {
1380         if (itemList.at(i)->type() == AVWIDGET) {
1381             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
1382             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true, deleteSelected);
1383         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
1384             Transition *item = static_cast <Transition *>(itemList.at(i));
1385             ItemInfo info;
1386             info.startPos = item->startPos();
1387             info.endPos = item->endPos();
1388             info.track = item->track();
1389             new AddTransitionCommand(this, info, item->transitionEndTrack(), item->toXML(), true, true, deleteSelected);
1390         }
1391     }
1392     m_commandStack->push(deleteSelected);
1393 }
1394
1395 void CustomTrackView::changeClipSpeed() {
1396     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1397     if (itemList.count() == 0) {
1398         emit displayMessage(i18n("Select clip to change speed"), ErrorMessage);
1399         return;
1400     }
1401     QUndoCommand *changeSelected = new QUndoCommand();
1402     changeSelected->setText("Edit clip speed");
1403     for (int i = 0; i < itemList.count(); i++) {
1404         if (itemList.at(i)->type() == AVWIDGET) {
1405             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
1406             ItemInfo info = item->info();
1407             int percent = QInputDialog::getInteger(this, i18n("Edit Clip Speed"), i18n("New speed (percents)"), 100, 1, 300);
1408             double speed = (double) percent / 100.0;
1409             if (item->speed() != speed)
1410                 new ChangeSpeedCommand(this, info, item->speed(), speed, item->clipProducer(), true, changeSelected);
1411         }
1412     }
1413     m_commandStack->push(changeSelected);
1414 }
1415
1416 void CustomTrackView::doChangeClipSpeed(ItemInfo info, double speed, const QString &id) {
1417     DocClipBase *baseclip = m_document->clipManager()->getClipById(id);
1418     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
1419     info.track = m_scene->m_tracksList.count() - item->track();
1420     m_document->renderer()->mltChangeClipSpeed(info, speed, baseclip->producer());
1421     item->setSpeed(speed);
1422     GenTime maxDuration = item->maxDuration();
1423     if (maxDuration < item->duration()) {
1424         info = item->info();
1425         ItemInfo endInfo = info;
1426         endInfo.endPos = info.startPos + maxDuration;
1427         ResizeClipCommand *command = new ResizeClipCommand(this, info, endInfo, true);
1428         m_commandStack->push(command);
1429     }
1430 }
1431
1432 void CustomTrackView::cutSelectedClips() {
1433     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1434     GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
1435     for (int i = 0; i < itemList.count(); i++) {
1436         if (itemList.at(i)->type() == AVWIDGET) {
1437             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
1438             if (currentPos > item->startPos() && currentPos <  item->endPos()) {
1439                 RazorClipCommand *command = new RazorClipCommand(this, item->info(), currentPos, true);
1440                 m_commandStack->push(command);
1441             }
1442         }
1443     }
1444 }
1445
1446 void CustomTrackView::addClip(QDomElement xml, const QString &clipId, ItemInfo info, EffectsList effects) {
1447     DocClipBase *baseclip = m_document->clipManager()->getClipById(clipId);
1448     ClipItem *item = new ClipItem(baseclip, info, m_document->fps());
1449     item->setEffectList(effects);
1450     scene()->addItem(item);
1451     baseclip->addReference();
1452     m_document->updateClip(baseclip->getId());
1453     info.track = m_scene->m_tracksList.count() - info.track;
1454     m_document->renderer()->mltInsertClip(info, xml, baseclip->producer());
1455     for (int i = 0; i < item->effectsCount(); i++) {
1456         m_document->renderer()->mltAddEffect(info.track, info.startPos, item->getEffectArgs(item->effectAt(i)), false);
1457     }
1458     m_document->renderer()->doRefresh();
1459 }
1460
1461 void CustomTrackView::slotUpdateClip(const QString &clipId) {
1462     QList<QGraphicsItem *> list = scene()->items();
1463     ClipItem *clip = NULL;
1464     for (int i = 0; i < list.size(); ++i) {
1465         if (list.at(i)->type() == AVWIDGET) {
1466             clip = static_cast <ClipItem *>(list.at(i));
1467             if (clip->clipProducer() == clipId) {
1468                 clip->refreshClip();
1469                 ItemInfo info = clip->info();
1470                 info.track = m_scene->m_tracksList.count() - clip->track();
1471                 m_document->renderer()->mltUpdateClip(info, clip->xml(), clip->baseClip()->producer());
1472             }
1473         }
1474     }
1475 }
1476
1477 ClipItem *CustomTrackView::getClipItemAt(int pos, int track) {
1478     QList<QGraphicsItem *> list = scene()->items(QPointF(pos , track * m_tracksHeight + m_tracksHeight / 2));
1479     ClipItem *clip = NULL;
1480     for (int i = 0; i < list.size(); ++i) {
1481         if (list.at(i)->type() == AVWIDGET) {
1482             clip = static_cast <ClipItem *>(list.at(i));
1483             break;
1484         }
1485     }
1486     return clip;
1487 }
1488
1489 ClipItem *CustomTrackView::getClipItemAt(GenTime pos, int track) {
1490     int framepos = (int)(pos.frames(m_document->fps()));
1491     return getClipItemAt(framepos, track);
1492 }
1493
1494 Transition *CustomTrackView::getTransitionItemAt(int pos, int track) {
1495     QList<QGraphicsItem *> list = scene()->items(QPointF(pos, (track + 1) * m_tracksHeight));
1496     Transition *clip = NULL;
1497     for (int i = 0; i < list.size(); ++i) {
1498         if (list.at(i)->type() == TRANSITIONWIDGET) {
1499             clip = static_cast <Transition *>(list.at(i));
1500             break;
1501         }
1502     }
1503     return clip;
1504 }
1505
1506 Transition *CustomTrackView::getTransitionItemAt(GenTime pos, int track) {
1507     int framepos = (int)(pos.frames(m_document->fps()));
1508     return getTransitionItemAt(framepos, track);
1509 }
1510
1511 void CustomTrackView::moveClip(const ItemInfo start, const ItemInfo end) {
1512     ClipItem *item = getClipItemAt((int) start.startPos.frames(m_document->fps()) + 1, start.track);
1513     if (!item) {
1514         emit displayMessage(i18n("Cannot move clip at time: %1s on track %2", QString::number(start.startPos.seconds(), 'g', 2), start.track), ErrorMessage);
1515         kDebug() << "----------------  ERROR, CANNOT find clip to move at.. ";// << startPos.x() * m_scale * FRAME_SIZE + 1 << ", " << startPos.y() * m_tracksHeight + m_tracksHeight / 2;
1516         return;
1517     }
1518     //kDebug() << "----------------  Move CLIP FROM: " << startPos.x() << ", END:" << endPos.x() << ",TRACKS: " << startPos.y() << " TO " << endPos.y();
1519
1520     bool success = m_document->renderer()->mltMoveClip((int)(m_scene->m_tracksList.count() - start.track), (int)(m_scene->m_tracksList.count() - end.track), (int) start.startPos.frames(m_document->fps()), (int)end.startPos.frames(m_document->fps()));
1521     if (success) {
1522         item->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
1523     } else {
1524         // undo last move and emit error message
1525         emit displayMessage(i18n("Cannot move clip to position %1seconds", QString::number(end.startPos.seconds(), 'g', 2)), ErrorMessage);
1526     }
1527 }
1528
1529 void CustomTrackView::moveTransition(const ItemInfo start, const ItemInfo end) {
1530     Transition *item = getTransitionItemAt((int)start.startPos.frames(m_document->fps()) + 1, start.track);
1531     if (!item) {
1532         emit displayMessage(i18n("Cannot move transition at time: %1s on track %2", start.startPos.seconds(), start.track), ErrorMessage);
1533         kDebug() << "----------------  ERROR, CANNOT find transition to move... ";// << startPos.x() * m_scale * FRAME_SIZE + 1 << ", " << startPos.y() * m_tracksHeight + m_tracksHeight / 2;
1534         return;
1535     }
1536     //kDebug() << "----------------  Move TRANSITION FROM: " << startPos.x() << ", END:" << endPos.x() << ",TRACKS: " << oldtrack << " TO " << newtrack;
1537
1538     //kDebug()<<"///  RESIZE TRANS START: ("<< startPos.x()<<"x"<< startPos.y()<<") / ("<<endPos.x()<<"x"<< endPos.y()<<")";
1539     if (end.endPos - end.startPos == start.endPos - start.startPos) {
1540         // Transition was moved
1541         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
1542     } else if (end.endPos == start.endPos) {
1543         // Transition start resize
1544         item->resizeStart((int) end.startPos.frames(m_document->fps()));
1545     } else {
1546         // Transition end resize;
1547         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
1548     }
1549     //item->moveTransition(GenTime((int) (endPos.x() - startPos.x()), m_document->fps()));
1550     item->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
1551     m_document->renderer()->mltMoveTransition(item->transitionTag(), m_scene->m_tracksList.count() - start.track, m_scene->m_tracksList.count() - end.track, item->transitionEndTrack(), start.startPos, start.endPos, end.startPos, end.endPos);
1552 }
1553
1554 void CustomTrackView::resizeClip(const ItemInfo start, const ItemInfo end) {
1555     int offset = 0;
1556     bool resizeClipStart = true;
1557     if (start.startPos == end.startPos) resizeClipStart = false;
1558     /*if (resizeClipStart) offset = 1;
1559     else offset = -1;*/
1560     ClipItem *item = getClipItemAt((int)(start.startPos.frames(m_document->fps()) + offset), start.track);
1561     if (!item) {
1562         emit displayMessage(i18n("Cannot move clip at time: %1s on track %2", start.startPos.seconds(), start.track), ErrorMessage);
1563         kDebug() << "----------------  ERROR, CANNOT find clip to resize at... "; // << startPos;
1564         return;
1565     }
1566     if (resizeClipStart) {
1567         ItemInfo clipinfo = item->info();
1568         clipinfo.track = m_scene->m_tracksList.count() - clipinfo.track;
1569         bool success = m_document->renderer()->mltResizeClipStart(clipinfo, end.startPos - item->startPos());
1570         if (success) {
1571             item->resizeStart((int) end.startPos.frames(m_document->fps()));
1572             updateClipFade(item);
1573         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
1574     } else {
1575         ItemInfo clipinfo = item->info();
1576         clipinfo.track = m_scene->m_tracksList.count() - clipinfo.track;
1577         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, end.endPos - clipinfo.startPos);
1578         if (success) {
1579             item->resizeEnd((int) end.endPos.frames(m_document->fps()));
1580             updateClipFade(item, true);
1581         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
1582     }
1583     m_document->renderer()->doRefresh();
1584 }
1585
1586 void CustomTrackView::updateClipFade(ClipItem * item, bool updateFadeOut) {
1587     if (!updateFadeOut) {
1588         int end = item->fadeIn();
1589         if (end != 0) {
1590             // there is a fade in effect
1591             QStringList clipeffects = item->effectNames();
1592             QDomElement oldeffect = item->effectAt(clipeffects.indexOf("Fade in"));
1593             int start = item->cropStart().frames(m_document->fps());
1594             end += start;
1595             EffectsList::setParameter(oldeffect, "in", QString::number(start));
1596             EffectsList::setParameter(oldeffect, "out", QString::number(end));
1597             QHash <QString, QString> effectParams = item->getEffectArgs(oldeffect);
1598             if (!m_document->renderer()->mltEditEffect(m_scene->m_tracksList.count() - item->track(), item->startPos(), effectParams))
1599                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
1600         }
1601     } else {
1602         int start = item->fadeOut();
1603         if (start != 0) {
1604             // there is a fade in effect
1605             QStringList clipeffects = item->effectNames();
1606             QDomElement oldeffect = item->effectAt(clipeffects.indexOf("Fade out"));
1607             int end = (item->duration() - item->cropStart()).frames(m_document->fps());
1608             start = end - start;
1609             EffectsList::setParameter(oldeffect, "in", QString::number(start));
1610             EffectsList::setParameter(oldeffect, "out", QString::number(end));
1611             QHash <QString, QString> effectParams = item->getEffectArgs(oldeffect);
1612             if (m_document->renderer()->mltEditEffect(m_scene->m_tracksList.count() - item->track(), item->startPos(), effectParams))
1613                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
1614         }
1615     }
1616 }
1617
1618 double CustomTrackView::getSnapPointForPos(double pos) {
1619     return m_scene->getSnapPointForPos(pos);
1620 }
1621
1622 void CustomTrackView::updateSnapPoints(AbstractClipItem *selected) {
1623     QList <GenTime> snaps;
1624     GenTime offset;
1625     if (selected) offset = selected->duration();
1626     QList<QGraphicsItem *> itemList = items();
1627     for (int i = 0; i < itemList.count(); i++) {
1628         if (itemList.at(i)->type() == AVWIDGET && itemList.at(i) != selected) {
1629             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
1630             GenTime start = item->startPos();
1631             GenTime end = item->endPos();
1632             snaps.append(start);
1633             snaps.append(end);
1634             QList < GenTime > markers = item->snapMarkers();
1635             for (int i = 0; i < markers.size(); ++i) {
1636                 GenTime t = markers.at(i);
1637                 snaps.append(t);
1638                 if (t > offset) snaps.append(t - offset);
1639             }
1640             if (offset != GenTime()) {
1641                 if (start > offset) snaps.append(start - offset);
1642                 if (end > offset) snaps.append(end - offset);
1643             }
1644         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
1645             Transition *transition = static_cast <Transition*>(itemList.at(i));
1646             GenTime start = transition->startPos();
1647             GenTime end = transition->endPos();
1648             snaps.append(start);
1649             snaps.append(end);
1650             if (offset != GenTime()) {
1651                 if (start > offset) snaps.append(start - offset);
1652                 if (end > offset) snaps.append(end - offset);
1653             }
1654         }
1655     }
1656
1657     // add cursor position
1658     GenTime pos = GenTime(m_cursorPos, m_document->fps());
1659     snaps.append(pos);
1660     if (offset != GenTime()) snaps.append(pos - offset);
1661
1662     // add guides
1663     for (int i = 0; i < m_guides.count(); i++) {
1664         snaps.append(m_guides.at(i)->position());
1665         if (offset != GenTime()) snaps.append(m_guides.at(i)->position() - offset);
1666     }
1667
1668     qSort(snaps);
1669     m_scene->setSnapList(snaps);
1670     //for (int i = 0; i < m_snapPoints.size(); ++i)
1671     //    kDebug() << "SNAP POINT: " << m_snapPoints.at(i).frames(25);
1672 }
1673
1674 void CustomTrackView::slotSeekToPreviousSnap() {
1675     updateSnapPoints(NULL);
1676     GenTime res = m_scene->previousSnapPoint(GenTime(m_cursorPos, m_document->fps()));
1677     setCursorPos((int) res.frames(m_document->fps()));
1678     checkScrolling();
1679 }
1680
1681 void CustomTrackView::slotSeekToNextSnap() {
1682     updateSnapPoints(NULL);
1683     GenTime res = m_scene->nextSnapPoint(GenTime(m_cursorPos, m_document->fps()));
1684     setCursorPos((int) res.frames(m_document->fps()));
1685     checkScrolling();
1686 }
1687
1688 void CustomTrackView::clipStart() {
1689     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1690     for (int i = 0; i < itemList.count(); i++) {
1691         if (itemList.at(i)->type() == AVWIDGET) {
1692             ClipItem *item = (ClipItem *) itemList.at(i);
1693             setCursorPos((int) item->startPos().frames(m_document->fps()));
1694             checkScrolling();
1695             break;
1696         }
1697     }
1698 }
1699
1700 void CustomTrackView::clipEnd() {
1701     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1702     for (int i = 0; i < itemList.count(); i++) {
1703         if (itemList.at(i)->type() == AVWIDGET) {
1704             ClipItem *item = (ClipItem *) itemList.at(i);
1705             setCursorPos((int) item->endPos().frames(m_document->fps()));
1706             checkScrolling();
1707             break;
1708         }
1709     }
1710 }
1711
1712 void CustomTrackView::slotAddClipMarker() {
1713     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1714     if (itemList.count() != 1) {
1715         emit displayMessage(i18n("Cannot add marker if more than one clip is selected"), ErrorMessage);
1716         kDebug() << "// CANNOT ADD MARKER IF MORE TAN ONE CLIP IS SELECTED....";
1717         return;
1718     }
1719     AbstractClipItem *item = (AbstractClipItem *)itemList.at(0);
1720     if (item->type() != AVWIDGET) return;
1721     GenTime pos = GenTime(m_cursorPos, m_document->fps());
1722     if (item->startPos() > pos || item->endPos() < pos) return;
1723     ClipItem *clip = (ClipItem *) item;
1724     QString id = clip->baseClip()->getId();
1725     GenTime position = pos - item->startPos() + item->cropStart();
1726     CommentedTime marker(position, i18n("Marker"));
1727     MarkerDialog d(clip->baseClip(), marker, m_document->timecode(), this);
1728     if (d.exec() == QDialog::Accepted) {
1729         slotAddClipMarker(id, d.newMarker().time(), d.newMarker().comment());
1730     }
1731 }
1732
1733 void CustomTrackView::slotAddClipMarker(const QString &id, GenTime t, QString c) {
1734     QString oldcomment = m_document->clipManager()->getClipById(id)->markerComment(t);
1735     AddMarkerCommand *command = new AddMarkerCommand(this, oldcomment, c, id, t, true);
1736     m_commandStack->push(command);
1737 }
1738
1739 void CustomTrackView::slotDeleteClipMarker() {
1740     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1741     if (itemList.count() != 1) {
1742         emit displayMessage(i18n("Cannot delete marker if more than one clip is selected"), ErrorMessage);
1743         kDebug() << "// CANNOT DELETE MARKER IF MORE TAN ONE CLIP IS SELECTED....";
1744         return;
1745     }
1746     AbstractClipItem *item = (AbstractClipItem *)itemList.at(0);
1747     if (item->type() != AVWIDGET) {
1748         emit displayMessage(i18n("No clip selected"), ErrorMessage);
1749         return;
1750     }
1751     GenTime pos = GenTime(m_cursorPos, m_document->fps());
1752     if (item->startPos() > pos || item->endPos() < pos) {
1753         emit displayMessage(i18n("No selected clip at cursor time"), ErrorMessage);
1754         return;
1755     }
1756     ClipItem *clip = (ClipItem *) item;
1757     QString id = clip->baseClip()->getId();
1758     GenTime position = pos - item->startPos() + item->cropStart();
1759     QString comment = clip->baseClip()->markerComment(position);
1760     if (comment.isEmpty()) {
1761         emit displayMessage(i18n("No marker found at cursor time"), ErrorMessage);
1762         return;
1763     }
1764     AddMarkerCommand *command = new AddMarkerCommand(this, comment, QString(), id, position, true);
1765     m_commandStack->push(command);
1766 }
1767
1768 void CustomTrackView::slotDeleteAllClipMarkers() {
1769     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1770     if (itemList.count() != 1) {
1771         emit displayMessage(i18n("Cannot delete marker if more than one clip is selected"), ErrorMessage);
1772         kDebug() << "// CANNOT DELETE MARKER IF MORE TAN ONE CLIP IS SELECTED....";
1773         return;
1774     }
1775     AbstractClipItem *item = (AbstractClipItem *)itemList.at(0);
1776     if (item->type() != AVWIDGET) {
1777         emit displayMessage(i18n("No clip selected"), ErrorMessage);
1778         return;
1779     }
1780
1781     ClipItem *clip = static_cast <ClipItem *>(item);
1782     QList <CommentedTime> markers = clip->baseClip()->commentedSnapMarkers();
1783
1784     if (markers.isEmpty()) {
1785         emit displayMessage(i18n("Clip has no markers"), ErrorMessage);
1786         return;
1787     }
1788     QString id = clip->baseClip()->getId();
1789     QUndoCommand *deleteMarkers = new QUndoCommand();
1790     deleteMarkers->setText("Delete clip markers");
1791
1792     for (int i = 0; i < markers.size(); i++) {
1793         new AddMarkerCommand(this, markers.at(i).comment(), QString(), id, markers.at(i).time(), true, deleteMarkers);
1794     }
1795     m_commandStack->push(deleteMarkers);
1796 }
1797
1798 void CustomTrackView::slotEditClipMarker() {
1799     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1800     if (itemList.count() != 1) {
1801         emit displayMessage(i18n("Cannot edit marker if more than one clip is selected"), ErrorMessage);
1802         kDebug() << "// CANNOT DELETE MARKER IF MORE TAN ONE CLIP IS SELECTED....";
1803         return;
1804     }
1805     AbstractClipItem *item = (AbstractClipItem *)itemList.at(0);
1806     if (item->type() != AVWIDGET) {
1807         emit displayMessage(i18n("No clip at cursor time"), ErrorMessage);
1808         return;
1809     }
1810     GenTime pos = GenTime(m_cursorPos, m_document->fps());
1811     if (item->startPos() > pos || item->endPos() < pos) {
1812         emit displayMessage(i18n("No selected clip at cursor time"), ErrorMessage);
1813         return;
1814     }
1815     ClipItem *clip = (ClipItem *) item;
1816     QString id = clip->baseClip()->getId();
1817     GenTime position = pos - item->startPos() + item->cropStart();
1818     QString oldcomment = clip->baseClip()->markerComment(position);
1819     if (oldcomment.isEmpty()) {
1820         emit displayMessage(i18n("No marker found at cursor time"), ErrorMessage);
1821         return;
1822     }
1823
1824     CommentedTime marker(position, oldcomment);
1825     MarkerDialog d(clip->baseClip(), marker, m_document->timecode(), this);
1826     if (d.exec() == QDialog::Accepted) {
1827         if (d.newMarker().time() == position) {
1828             // marker position was not changed, only text
1829             AddMarkerCommand *command = new AddMarkerCommand(this, oldcomment, d.newMarker().comment(), id, position, true);
1830             m_commandStack->push(command);
1831         } else {
1832             // marker text and position were changed, remove previous marker and add new one
1833             AddMarkerCommand *command1 = new AddMarkerCommand(this, oldcomment, QString(), id, position, true);
1834             AddMarkerCommand *command2 = new AddMarkerCommand(this, QString(), d.newMarker().comment(), id, d.newMarker().time(), true);
1835             m_commandStack->push(command1);
1836             m_commandStack->push(command2);
1837         }
1838     }
1839 }
1840
1841 void CustomTrackView::addMarker(const QString &id, const GenTime &pos, const QString comment) {
1842     DocClipBase *base = m_document->clipManager()->getClipById(id);
1843     if (!comment.isEmpty()) base->addSnapMarker(pos, comment);
1844     else base->deleteSnapMarker(pos);
1845     m_document->setModified(true);
1846     viewport()->update();
1847 }
1848
1849
1850
1851 void CustomTrackView::editGuide(const GenTime oldPos, const GenTime pos, const QString &comment) {
1852     if (oldPos > GenTime() && pos > GenTime()) {
1853         // move guide
1854         for (int i = 0; i < m_guides.count(); i++) {
1855             if (m_guides.at(i)->position() == oldPos) {
1856                 Guide *item = m_guides.at(i);
1857                 item->updateGuide(pos, comment);
1858                 break;
1859             }
1860         }
1861     } else if (pos > GenTime()) addGuide(pos, comment);
1862     else {
1863         // remove guide
1864         bool found = false;
1865         for (int i = 0; i < m_guides.count(); i++) {
1866             if (m_guides.at(i)->position() == oldPos) {
1867                 Guide *item = m_guides.takeAt(i);
1868                 delete item;
1869                 found = true;
1870                 break;
1871             }
1872         }
1873         if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
1874     }
1875     m_document->syncGuides(m_guides);
1876 }
1877
1878 bool CustomTrackView::addGuide(const GenTime pos, const QString &comment) {
1879     for (int i = 0; i < m_guides.count(); i++) {
1880         if (m_guides.at(i)->position() == pos) {
1881             emit displayMessage(i18n("A guide already exists at that position"), ErrorMessage);
1882             return false;
1883         }
1884     }
1885     Guide *g = new Guide(this, pos, comment, m_document->fps(), m_tracksHeight * m_scene->m_tracksList.count());
1886     scene()->addItem(g);
1887     m_guides.append(g);
1888     m_document->syncGuides(m_guides);
1889     return true;
1890 }
1891
1892 void CustomTrackView::slotAddGuide() {
1893     CommentedTime marker(GenTime(m_cursorPos, m_document->fps()), i18n("Guide"));
1894     MarkerDialog d(NULL, marker, m_document->timecode(), this);
1895     if (d.exec() != QDialog::Accepted) return;
1896     if (addGuide(d.newMarker().time(), d.newMarker().comment())) {
1897         EditGuideCommand *command = new EditGuideCommand(this, GenTime(), QString(), d.newMarker().time(), d.newMarker().comment(), false);
1898         m_commandStack->push(command);
1899     }
1900 }
1901
1902 void CustomTrackView::slotEditGuide() {
1903     GenTime pos = GenTime(m_cursorPos, m_document->fps());
1904     bool found = false;
1905     for (int i = 0; i < m_guides.count(); i++) {
1906         if (m_guides.at(i)->position() == pos) {
1907             slotEditGuide(m_guides.at(i)->info());
1908             found = true;
1909             break;
1910         }
1911     }
1912     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
1913 }
1914
1915 void CustomTrackView::slotEditGuide(CommentedTime guide) {
1916     MarkerDialog d(NULL, guide, m_document->timecode(), this);
1917     if (d.exec() == QDialog::Accepted) {
1918         EditGuideCommand *command = new EditGuideCommand(this, guide.time(), guide.comment(), d.newMarker().time(), d.newMarker().comment(), true);
1919         m_commandStack->push(command);
1920     }
1921 }
1922
1923
1924 void CustomTrackView::slotDeleteGuide() {
1925     GenTime pos = GenTime(m_cursorPos, m_document->fps());
1926     bool found = false;
1927     for (int i = 0; i < m_guides.count(); i++) {
1928         if (m_guides.at(i)->position() == pos) {
1929             EditGuideCommand *command = new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true);
1930             m_commandStack->push(command);
1931             found = true;
1932             break;
1933         }
1934     }
1935     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
1936 }
1937
1938 void CustomTrackView::slotDeleteAllGuides() {
1939     QUndoCommand *deleteAll = new QUndoCommand();
1940     deleteAll->setText("Delete all guides");
1941     for (int i = 0; i < m_guides.count(); i++) {
1942         EditGuideCommand *command = new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true, deleteAll);
1943     }
1944     m_commandStack->push(deleteAll);
1945 }
1946
1947 void CustomTrackView::setTool(PROJECTTOOL tool) {
1948     m_tool = tool;
1949 }
1950
1951 void CustomTrackView::setScale(double scaleFactor) {
1952     QMatrix matrix;
1953     matrix = matrix.scale(scaleFactor, 1);
1954     m_scene->setScale(scaleFactor);
1955     //scale(scaleFactor, 1);
1956     m_animationTimer->stop();
1957     if (m_visualTip) {
1958         delete m_visualTip;
1959         m_visualTip = NULL;
1960     }
1961     if (m_animation) {
1962         delete m_animation;
1963         m_animation = NULL;
1964     }
1965     /*double pos = cursorPos() / m_scale;
1966     m_scale = scaleFactor;
1967     m_scene->setScale(m_scale);
1968     int vert = verticalScrollBar()->value();
1969     kDebug() << " HHHHHHHH  SCALING: " << m_scale;
1970     QList<QGraphicsItem *> itemList = items();
1971     for (int i = 0; i < itemList.count(); i++) {
1972         if (itemList.at(i)->type() == AVWIDGET || itemList.at(i)->type() == TRANSITIONWIDGET) {
1973             AbstractClipItem *clip = (AbstractClipItem *)itemList.at(i);
1974             clip->setRect(0, 0, (qreal) clip->duration().frames(m_document->fps()) * m_scale - .5, clip->rect().height());
1975             clip->setPos((qreal) clip->startPos().frames(m_document->fps()) * m_scale, clip->pos().y());
1976         }
1977     }
1978
1979     for (int i = 0; i < m_guides.count(); i++) {
1980         m_guides.at(i)->updatePosition(m_scale);
1981     }
1982
1983     setSceneRect(0, 0, (m_projectDuration + 100) * m_scale, sceneRect().height());
1984     updateCursorPos();*/
1985     setMatrix(matrix);
1986     centerOn(QPointF(cursorPos(), m_tracksHeight));
1987     //verticalScrollBar()->setValue(vert);*/
1988 }
1989
1990 void CustomTrackView::slotRefreshGuides() {
1991     if (KdenliveSettings::showmarkers()) {
1992         kDebug() << "// refresh GUIDES";
1993         for (int i = 0; i < m_guides.count(); i++) {
1994             m_guides.at(i)->update();
1995         }
1996     }
1997 }
1998
1999 void CustomTrackView::drawBackground(QPainter * painter, const QRectF & rect) {
2000     QColor base = palette().button().color();
2001     QRectF r = rect;
2002     r.setWidth(r.width() + 1);
2003     painter->setClipRect(r);
2004     painter->drawLine(r.left(), 0, r.right(), 0);
2005     uint max = m_scene->m_tracksList.count();
2006     for (uint i = 0; i < max;i++) {
2007         /*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)));
2008                else*/
2009         if (m_scene->m_tracksList.at(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)));
2010         painter->drawLine(r.left(), m_tracksHeight * (i + 1), r.right(), m_tracksHeight * (i + 1));
2011     }
2012     int lowerLimit = m_tracksHeight * m_scene->m_tracksList.count() + 1;
2013     if (height() > lowerLimit)
2014         painter->fillRect(QRectF(r.left(), lowerLimit, r.width(), height() - lowerLimit), QBrush(base));
2015 }
2016
2017 bool CustomTrackView::findString(const QString &text) {
2018     QString marker;
2019     for (int i = 0; i < m_searchPoints.size(); ++i) {
2020         marker = m_searchPoints.at(i).comment();
2021         if (marker.contains(text, Qt::CaseInsensitive)) {
2022             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
2023             int vert = verticalScrollBar()->value();
2024             int hor = cursorPos();
2025             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
2026             m_findIndex = i;
2027             return true;
2028         }
2029     }
2030     return false;
2031 }
2032
2033 bool CustomTrackView::findNextString(const QString &text) {
2034     QString marker;
2035     for (int i = m_findIndex + 1; i < m_searchPoints.size(); ++i) {
2036         marker = m_searchPoints.at(i).comment();
2037         if (marker.contains(text, Qt::CaseInsensitive)) {
2038             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
2039             int vert = verticalScrollBar()->value();
2040             int hor = cursorPos();
2041             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
2042             m_findIndex = i;
2043             return true;
2044         }
2045     }
2046     m_findIndex = -1;
2047     return false;
2048 }
2049
2050 void CustomTrackView::initSearchStrings() {
2051     m_searchPoints.clear();
2052     QList<QGraphicsItem *> itemList = items();
2053     for (int i = 0; i < itemList.count(); i++) {
2054         // parse all clip names
2055         if (itemList.at(i)->type() == AVWIDGET) {
2056             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2057             GenTime start = item->startPos();
2058             CommentedTime t(start, item->clipName());
2059             m_searchPoints.append(t);
2060             // add all clip markers
2061             QList < CommentedTime > markers = item->commentedSnapMarkers();
2062             m_searchPoints += markers;
2063         }
2064     }
2065
2066     // add guides
2067     for (int i = 0; i < m_guides.count(); i++) {
2068         m_searchPoints.append(m_guides.at(i)->info());
2069     }
2070
2071     qSort(m_searchPoints);
2072 }
2073
2074 void CustomTrackView::clearSearchStrings() {
2075     m_searchPoints.clear();
2076     m_findIndex = 0;
2077 }
2078
2079 void CustomTrackView::copyClip() {
2080     while (m_copiedItems.count() > 0) {
2081         delete m_copiedItems.takeFirst();
2082     }
2083     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2084     if (itemList.count() == 0) {
2085         emit displayMessage(i18n("Select a clip before copying"), ErrorMessage);
2086         return;
2087     }
2088     for (int i = 0; i < itemList.count(); i++) {
2089         if (itemList.at(i)->type() == AVWIDGET) {
2090             ClipItem *dup = static_cast <ClipItem *>(itemList.at(i));
2091             m_copiedItems.append(dup->clone(dup->info()));
2092         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
2093             Transition *dup = static_cast <Transition *>(itemList.at(i));
2094             m_copiedItems.append(dup->clone());
2095         }
2096     }
2097 }
2098
2099 bool CustomTrackView::canBePastedTo(ItemInfo info, int type) const {
2100     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));
2101     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
2102     for (int i = 0; i < collisions.count(); i++) {
2103         if (collisions.at(i)->type() == type) return false;
2104     }
2105     return true;
2106 }
2107
2108 bool CustomTrackView::canBePasted(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const {
2109     for (int i = 0; i < items.count(); i++) {
2110         ItemInfo info = items.at(i)->info();
2111         info.startPos += offset;
2112         info.endPos += offset;
2113         info.track += trackOffset;
2114         if (!canBePastedTo(info, items.at(i)->type())) return false;
2115     }
2116     return true;
2117 }
2118
2119 bool CustomTrackView::canBeMoved(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const {
2120     QPainterPath movePath;
2121     movePath.moveTo(0, 0);
2122
2123     for (int i = 0; i < items.count(); i++) {
2124         ItemInfo info = items.at(i)->info();
2125         info.startPos = info.startPos + offset;
2126         info.endPos = info.endPos + offset;
2127         info.track = info.track + trackOffset;
2128         if (info.startPos < GenTime()) {
2129             // No clip should go below 0
2130             return false;
2131         }
2132         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));
2133         movePath.addRect(rect);
2134     }
2135     QList<QGraphicsItem *> collisions = scene()->items(movePath, Qt::IntersectsItemBoundingRect);
2136     for (int i = 0; i < collisions.count(); i++) {
2137         if ((collisions.at(i)->type() == AVWIDGET || collisions.at(i)->type() == TRANSITIONWIDGET) && !items.contains(static_cast <AbstractClipItem *>(collisions.at(i)))) {
2138             kDebug() << "  ////////////   CLIP COLLISION, MOVE NOT ALLOWED";
2139             return false;
2140         }
2141     }
2142     return true;
2143 }
2144
2145 void CustomTrackView::pasteClip() {
2146     if (m_copiedItems.count() == 0) {
2147         emit displayMessage(i18n("No clip copied"), ErrorMessage);
2148         return;
2149     }
2150     QPoint position;
2151     if (m_menuPosition.isNull()) position = mapFromGlobal(QCursor::pos());
2152     else position = m_menuPosition;
2153     GenTime pos = GenTime((int)(mapToScene(position).x()), m_document->fps());
2154     int track = (int)(position.y() / m_tracksHeight);
2155     ItemInfo first = m_copiedItems.at(0)->info();
2156
2157     GenTime offset = pos - first.startPos;
2158     int trackOffset = track - first.track;
2159
2160     if (!canBePasted(m_copiedItems, offset, trackOffset)) {
2161         emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
2162         return;
2163     }
2164     QUndoCommand *pasteClips = new QUndoCommand();
2165     pasteClips->setText("Paste clips");
2166
2167     for (int i = 0; i < m_copiedItems.count(); i++) {
2168         // parse all clip names
2169         if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == AVWIDGET) {
2170             ClipItem *clip = static_cast <ClipItem *>(m_copiedItems.at(i));
2171             ItemInfo info;
2172             info.startPos = clip->startPos() + offset;
2173             info.endPos = clip->endPos() + offset;
2174             info.cropStart = clip->cropStart();
2175             info.track = clip->track() + trackOffset;
2176             if (canBePastedTo(info, AVWIDGET)) {
2177                 new AddTimelineClipCommand(this, clip->xml(), clip->clipProducer(), info, clip->effectList(), true, false, pasteClips);
2178             } else emit displayMessage(i18n("Cannot paste clip to selected place"), ErrorMessage);
2179         } else if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == TRANSITIONWIDGET) {
2180             Transition *tr = static_cast <Transition *>(m_copiedItems.at(i));
2181             ItemInfo info;
2182             info.startPos = tr->startPos() + offset;
2183             info.endPos = tr->endPos() + offset;
2184             info.track = tr->track() + trackOffset;
2185             if (canBePastedTo(info, TRANSITIONWIDGET)) {
2186                 new AddTransitionCommand(this, info, tr->transitionEndTrack() + trackOffset, tr->toXML(), false, true, pasteClips);
2187             } else emit displayMessage(i18n("Cannot paste transition to selected place"), ErrorMessage);
2188         }
2189     }
2190     m_commandStack->push(pasteClips);
2191 }
2192
2193 void CustomTrackView::pasteClipEffects() {
2194     if (m_copiedItems.count() != 1 || m_copiedItems.at(0)->type() != AVWIDGET) {
2195         emit displayMessage(i18n("You must copy exactly one clip before pasting effects"), ErrorMessage);
2196         return;
2197     }
2198     ClipItem *clip = static_cast < ClipItem *>(m_copiedItems.at(0));
2199     EffectsList effects = clip->effectList();
2200
2201     QUndoCommand *paste = new QUndoCommand();
2202     paste->setText("Paste effects");
2203
2204     QList<QGraphicsItem *> clips = scene()->selectedItems();
2205     for (int i = 0; i < clips.count(); ++i) {
2206         if (clips.at(i)->type() == AVWIDGET) {
2207             ClipItem *item = static_cast < ClipItem *>(clips.at(i));
2208             for (int i = 0; i < clip->effectsCount(); i++) {
2209                 new AddEffectCommand(this, m_scene->m_tracksList.count() - item->track(), item->startPos(), clip->effectAt(i), true, paste);
2210             }
2211         }
2212     }
2213     m_commandStack->push(paste);
2214 }
2215
2216
2217 /*
2218 void CustomTrackView::drawForeground ( QPainter * painter, const QRectF & rect )
2219 {
2220   //kDebug()<<"/////  DRAWING FB: "<<rect.x()<<", width: "<<rect.width();
2221   painter->fillRect(rect, QColor(50, rand() % 250,50,100));
2222   painter->drawLine(m_cursorPos, rect.y(), m_cursorPos, rect.y() + rect.height());
2223 }
2224 */
2225 #include "customtrackview.moc"