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