Overhaul of UBGraphicsMediaItem class

- Removed inheritance of UBGraphicsProxyWidget; cleaned up related code
- Added two children classes: UBGraphicsVideoItem and
UBGraphicsAudioItem. UBGraphicsMediaItem is now an abstract class.
- Better encapsulation; the Scene and other external classes no longer
access the mediaObject directly

There is now less distinction between audio and video items to outside
code: apart from the UBSvgSubsetAdaptor, there is no need to know
whether a media item holds a video or audio file. Creation is handled
through the static function `UBGraphicsMediaItem::createMediaItem(URL,
parent)`

src/adaptors/UBSvgSubsetAdaptor.cpp

@@ -661,9 +661,8 @@ UBGraphicsScene* UBSvgSubsetAdaptor::UBSvgSubsetReader::loadScene()
 
                     audioItem->show();
 
-                    //force start to load the video and display the first frame
-                    audioItem->mediaObject()->play();
-                    audioItem->mediaObject()->pause();
+                    audioItem->play();
+                    audioItem->pause();
                 }
             }
             else if (mXmlReader.name() == "video")
@@ -676,16 +675,12 @@ UBGraphicsScene* UBSvgSubsetAdaptor::UBSvgSubsetReader::loadScene()
                     videoItem->setFlag(QGraphicsItem::ItemIsSelectable, true);
 
                     mScene->addItem(videoItem);
-                    mScene->addItem(videoItem->videoItem());
-
-                    // Update the child QGraphicsVideoItem's transformation matrix
-                    videoItem->setMatrix(videoItem->matrix());
 
                     videoItem->show();
 
                     //force start to load the video and display the first frame
-                    videoItem->mediaObject()->play();
-                    videoItem->mediaObject()->pause();
+                    videoItem->play();
+                    videoItem->pause();
                 }
             }
             else if (mXmlReader.name() == "text")//This is for backward compatibility with proto text field prior to version 4.3
@@ -1210,14 +1205,17 @@ bool UBSvgSubsetAdaptor::UBSvgSubsetWriter::persistScene(int pageIndex)
             continue;
         }
 
-        UBGraphicsMediaItem *mediaItem = qgraphicsitem_cast<UBGraphicsMediaItem*> (item);
+        UBGraphicsVideoItem * videoItem = qgraphicsitem_cast<UBGraphicsVideoItem*> (item);
 
-        if (mediaItem && mediaItem->isVisible())
-        {
-            if (UBGraphicsMediaItem::mediaType_Video == mediaItem->getMediaType())
-                videoItemToLinkedVideo(mediaItem);
-            else
-                audioItemToLinkedAudio(mediaItem);
+        if (videoItem && videoItem->isVisible()) {
+            videoItemToLinkedVideo(videoItem);
+            continue;
+        }
+
+        UBGraphicsAudioItem * audioItem = qgraphicsitem_cast<UBGraphicsAudioItem*> (item);
+
+        if (audioItem && audioItem->isVisible()) {
+            audioItemToLinkedAudio(audioItem);
             continue;
         }
 
@@ -2019,15 +2017,16 @@ UBGraphicsPDFItem* UBSvgSubsetAdaptor::UBSvgSubsetReader::pdfItemFromPDF()
     return pdfItem;
 }
 
-void UBSvgSubsetAdaptor::UBSvgSubsetWriter::audioItemToLinkedAudio(UBGraphicsMediaItem* audioItem)
+void UBSvgSubsetAdaptor::UBSvgSubsetWriter::audioItemToLinkedAudio(UBGraphicsAudioItem *audioItem)
 {
     mXmlWriter.writeStartElement("audio");
 
     graphicsItemToSvg(audioItem);
 
-    if (audioItem->mediaObject()->state() == QMediaPlayer::PausedState && (audioItem->mediaObject()->duration() - audioItem->mediaObject()->position()) > 0)
+    if (audioItem->playerState() == QMediaPlayer::PausedState &&
+       (audioItem->mediaDuration() - audioItem->mediaPosition()) > 0)
     {
-        qint64 pos = audioItem->mediaObject()->position();
+        qint64 pos = audioItem->mediaPosition();
         mXmlWriter.writeAttribute(UBSettings::uniboardDocumentNamespaceUri, "position", QString("%1").arg(pos));
     }
 
@@ -2038,7 +2037,7 @@ void UBSvgSubsetAdaptor::UBSvgSubsetWriter::audioItemToLinkedAudio(UBGraphicsMed
 }
 
 
-void UBSvgSubsetAdaptor::UBSvgSubsetWriter::videoItemToLinkedVideo(UBGraphicsMediaItem* videoItem)
+void UBSvgSubsetAdaptor::UBSvgSubsetWriter::videoItemToLinkedVideo(UBGraphicsVideoItem* videoItem)
 {
     /* w3c sample
      *
@@ -2051,9 +2050,10 @@ void UBSvgSubsetAdaptor::UBSvgSubsetWriter::videoItemToLinkedVideo(UBGraphicsMed
 
     graphicsItemToSvg(videoItem);
 
-    if (videoItem->mediaObject()->state() == QMediaPlayer::PausedState && (videoItem->mediaObject()->duration() - videoItem->mediaObject()->position()) > 0)
+    if (videoItem->playerState() == QMediaPlayer::PausedState &&
+       (videoItem->mediaDuration() - videoItem->mediaPosition()) > 0)
     {
-        qint64 pos = videoItem->mediaObject()->position();
+        qint64 pos = videoItem->mediaPosition();
         mXmlWriter.writeAttribute(UBSettings::uniboardDocumentNamespaceUri, "position", QString("%1").arg(pos));
     }
 
@@ -2083,7 +2083,7 @@ UBGraphicsMediaItem* UBSvgSubsetAdaptor::UBSvgSubsetReader::audioItemFromSvg()
         href = mDocumentPath + "/" + href.right(href.length() - indexOfAudioDirectory);
     }
 
-    UBGraphicsMediaItem* audioItem = new UBGraphicsMediaItem(QUrl::fromLocalFile(href));
+    UBGraphicsMediaItem* audioItem = UBGraphicsMediaItem::createMediaItem(QUrl::fromLocalFile(href));
     if(audioItem)
         audioItem->connect(UBApplication::boardController, SIGNAL(activeSceneChanged()), audioItem, SLOT(activeSceneChanged()));
 
@@ -2118,7 +2118,7 @@ UBGraphicsMediaItem* UBSvgSubsetAdaptor::UBSvgSubsetReader::videoItemFromSvg()
         href = mDocumentPath + "/" + href.right(href.length() - indexOfAudioDirectory);
     }
 
-    UBGraphicsMediaItem* videoItem = new UBGraphicsMediaItem(QUrl::fromLocalFile(href));
+    UBGraphicsMediaItem* videoItem = UBGraphicsMediaItem::createMediaItem(QUrl::fromLocalFile(href));
     if(videoItem){
         videoItem->connect(UBApplication::boardController, SIGNAL(activeSceneChanged()), videoItem, SLOT(activeSceneChanged()));
     }

src/adaptors/UBSvgSubsetAdaptor.h

@@ -40,6 +40,8 @@ class UBGraphicsPixmapItem;
 class UBGraphicsPDFItem;
 class UBGraphicsWidgetItem;
 class UBGraphicsMediaItem;
+class UBGraphicsVideoItem;
+class UBGraphicsAudioItem;
 class UBGraphicsAppleWidgetItem;
 class UBGraphicsW3CWidgetItem;
 class UBGraphicsTextItem;
@@ -232,8 +234,8 @@ class UBSvgSubsetAdaptor
                 void pixmapItemToLinkedImage(UBGraphicsPixmapItem *pixmapItem);
                 void svgItemToLinkedSvg(UBGraphicsSvgItem *svgItem);
                 void pdfItemToLinkedPDF(UBGraphicsPDFItem *pdfItem);
-                void videoItemToLinkedVideo(UBGraphicsMediaItem *videoItem);
-                void audioItemToLinkedAudio(UBGraphicsMediaItem *audioItem);
+                void videoItemToLinkedVideo(UBGraphicsVideoItem *videoItem);
+                void audioItemToLinkedAudio(UBGraphicsAudioItem *audioItem);
                 void graphicsItemToSvg(QGraphicsItem *item);
                 void graphicsAppleWidgetToSvg(UBGraphicsAppleWidgetItem *item);
                 void graphicsW3CWidgetToSvg(UBGraphicsW3CWidgetItem *item);

src/board/UBBoardController.h

@@ -51,8 +51,6 @@ class UBVersion;
 class UBSoftwareUpdate;
 class UBSoftwareUpdateDialog;
 class UBGraphicsMediaItem;
-class UBGraphicsVideoItem;
-class UBGraphicsAudioItem;
 class UBGraphicsWidgetItem;
 class UBBoardPaletteManager;
 class UBItem;

src/core/UBPersistenceManager.cpp

@@ -566,7 +566,7 @@ void UBPersistenceManager::duplicateDocumentScene(UBDocumentProxy* proxy, int in
             QString fileName = QFileInfo(source).completeBaseName();
             destination = destination.replace(fileName,newUuid.toString());
             QFile::copy(source,destination);
-            mediaItem->mediaFileUrl(QUrl::fromLocalFile(destination));
+            mediaItem->setMediaFileUrl(QUrl::fromLocalFile(destination));
             continue;
         }
 

src/domain/UBGraphicsItemDelegate.cpp

@@ -1439,10 +1439,10 @@ void DelegateMediaControl::seekToMousePos(QPointF mousePos)
         mouseX = mSeecArea.width() - mSeecArea.height()/2;
 
     if (mTotalTimeInMs > 0 && length > 0 && mDelegate
-        && mDelegate->mediaObject() && mDelegate->mediaObject()->isSeekable())
+        && mDelegate->isMediaSeekable())
     {
         qint64 tickPos = (mTotalTimeInMs/length)* (mouseX - minX);
-        mDelegate->mediaObject()->setPosition(tickPos);
+        mDelegate->setMediaPos(tickPos);
 
         //OSX is a bit lazy
         updateTicker(tickPos);

src/domain/UBGraphicsMediaItem.h

@@ -45,7 +45,7 @@
 
 class QGraphicsVideoItem;
 
-class UBGraphicsMediaItem : public UBGraphicsProxyWidget
+class UBGraphicsMediaItem : public QObject, public UBItem, public UBGraphicsItem, public QGraphicsRectItem, public UBResizableGraphicsItem
 {
     Q_OBJECT
 
@@ -55,9 +55,6 @@ public:
         mediaType_Audio
     } mediaType;
 
-    UBGraphicsMediaItem(const QUrl& pMediaFileUrl, QGraphicsItem *parent = 0);
-    ~UBGraphicsMediaItem();
-
     enum { Type = UBGraphicsItemType::MediaItemType };
 
     virtual int type() const
@@ -65,48 +62,46 @@ public:
         return Type;
     }
 
-    virtual QUrl mediaFileUrl() const
-    {
-        return mMediaFileUrl;
-    }
+    static UBGraphicsMediaItem* createMediaItem(const QUrl& pMediaFileUrl, QGraphicsItem* parent = 0);
 
-    virtual void mediaFileUrl(QUrl url){mMediaFileUrl=url;}
+    UBGraphicsMediaItem(const QUrl& pMediaFileUrl, QGraphicsItem* parent = 0);
+    ~UBGraphicsMediaItem();
 
-    QMediaPlayer* mediaObject() const
-    {
-        return mMediaObject;
-    }
 
-    void setInitialPos(qint64 p) {
-        mInitialPos = p;
-    }
-    qint64 initialPos() {
-        return mInitialPos;
-    }
+    // Getters
 
-    bool isMuted() const
-    {
-        return mMuted;
-    }
+    virtual mediaType getMediaType() const = 0;
 
-    QGraphicsVideoItem * videoItem() const
-    {
-        return mVideoItem;
-    }
+    virtual UBGraphicsScene* scene();
+    bool hasLinkedImage() const             { return haveLinkedImage; }
+    virtual QUrl mediaFileUrl() const       { return mMediaFileUrl; }
+    bool isMuted() const                    { return mMuted; }
+    qint64 initialPos() const               { return mInitialPos; }
 
-    bool hasLinkedImage(){return haveLinkedImage;}
+    bool isMediaSeekable() const;
+    qint64 mediaDuration() const;
+    qint64 mediaPosition() const;
 
-    mediaType getMediaType() { return mMediaType; }
+    QMediaPlayer::State playerState() const;
 
-    virtual UBGraphicsScene* scene();
+    QRectF boundingRect() const;
 
-    virtual UBItem* deepCopy() const;
+    QSizeF size() const { return rect().size(); } 
+
+    // Setters
+    virtual void setMediaFileUrl(QUrl url);
+    void setInitialPos(qint64 p);
+    void setMediaPos(qint64 p);
+    virtual void setSourceUrl(const QUrl &pSourceUrl);
+    void setSelected(bool selected);
+    void setMinimumSize(const QSize& size);
 
     virtual void copyItemParameters(UBItem *copy) const;
 
-    virtual void setSourceUrl(const QUrl &pSourceUrl);
+    virtual void setSize(int width, int height);
+    void resize(qreal w, qreal h) { setSize(w, h); }
 
-    void setSelected(bool selected);
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
 
 
 public slots:
@@ -116,23 +111,22 @@ public slots:
     void activeSceneChanged();
     void hasMediaChanged(bool hasMedia);
     void showOnDisplayChanged(bool shown);
-    virtual void resize(qreal w, qreal h);
-    virtual void resize(const QSizeF & pSize);
+
+    virtual void play();
+    virtual void pause();
+    virtual void stop();
+    virtual void togglePlayPause();
 
 protected:
 
     virtual QVariant itemChange(GraphicsItemChange change, const QVariant &value);
     virtual void mousePressEvent(QGraphicsSceneMouseEvent *event);
-    virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
+
     virtual void clearSource();
 
     QMediaPlayer *mMediaObject;
-    QWidget *mDummyVideoWidget;
-    QGraphicsVideoItem *mVideoItem;
 
-    QWidget *mAudioWidget;
-
-private:
+    QSize mMinimumSize;
 
     bool mMuted;
     bool mMutedByUserAction;
@@ -141,8 +135,6 @@ private:
     QUrl mMediaFileUrl;
     QString mMediaSource;
 
-    mediaType mMediaType;
-
     bool mShouldMove;
     QPointF mMousePressPos;
     QPointF mMouseMovePos;
@@ -152,4 +144,40 @@ private:
 
     qint64 mInitialPos;
 };
+
+class UBGraphicsAudioItem: public UBGraphicsMediaItem
+{
+    Q_OBJECT
+
+public:
+
+    UBGraphicsAudioItem(const QUrl& pMediaFileUrl, QGraphicsItem *parent = 0);
+    mediaType getMediaType() const { return mediaType_Audio; }
+
+    virtual UBItem* deepCopy() const;
+};
+
+class UBGraphicsVideoItem: public UBGraphicsMediaItem
+{
+    Q_OBJECT
+
+public:
+
+    UBGraphicsVideoItem(const QUrl& pMediaFileUrl, QGraphicsItem *parent = 0);
+
+    mediaType getMediaType() const { return mediaType_Video; }
+
+    void setSize(int width, int height);
+
+    virtual UBItem* deepCopy() const;
+
+public slots:
+    void videoSizeChanged(QSizeF newSize);
+
+protected:
+
+    QGraphicsVideoItem *mVideoItem;
+};
+
+
 #endif // UBGRAPHICSMEDIAITEM_H

src/domain/UBGraphicsMediaItemDelegate.cpp

@@ -43,42 +43,17 @@
 
 #include "core/memcheck.h"
 
-UBGraphicsMediaItemDelegate::UBGraphicsMediaItemDelegate(UBGraphicsMediaItem* pDelegated, QMediaPlayer* pMedia, QObject * parent)
+UBGraphicsMediaItemDelegate::UBGraphicsMediaItemDelegate(UBGraphicsMediaItem* pDelegated, QObject * parent)
     : UBGraphicsItemDelegate(pDelegated, parent, GF_COMMON
                              | GF_RESPECT_RATIO
                              | GF_TOOLBAR_USED)
     , mPlayPauseButton(NULL)
-    , mMedia(pMedia)
     , mToolBarShowTimer(NULL)
     , m_iToolBarShowingInterval(5000)
 {
     QPalette palette;
     palette.setBrush ( QPalette::Light, Qt::darkGray );
 
-    mMedia->setNotifyInterval(50);
-
-    connect(mMedia, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)),
-            this, SLOT(mediaStatusChanged(QMediaPlayer::MediaStatus)));
-
-    connect(mMedia, SIGNAL(stateChanged(QMediaPlayer::State)),
-            this, SLOT(mediaStateChanged(QMediaPlayer::State)));
-
-    connect(mMedia, static_cast<void(QMediaPlayer::*)(QMediaPlayer::Error)>(&QMediaPlayer::error),
-        this, &UBGraphicsMediaItemDelegate::mediaError);
-
-    connect(mMedia, SIGNAL(positionChanged(qint64)),
-            this, SLOT(updateTicker(qint64)));
-
-    connect(mMedia, SIGNAL(durationChanged(qint64)),
-            this, SLOT(totalTimeChanged(qint64)));
-
-    if (delegated()->hasLinkedImage())
-    {
-        mToolBarShowTimer = new QTimer();
-        connect(mToolBarShowTimer, SIGNAL(timeout()), this, SLOT(hideToolBar()));
-        mToolBarShowTimer->setInterval(m_iToolBarShowingInterval);
-    }
-
     if (delegated()->isMuted())
         delegated()->setMute(true);
 
@@ -110,7 +85,7 @@ void UBGraphicsMediaItemDelegate::buildButtons()
 
         mStopButton = new DelegateButton(":/images/stop.svg", mDelegated, mToolBarItem, Qt::TitleBarArea);
         connect(mStopButton, SIGNAL(clicked(bool)),
-                mMedia, SLOT(stop()));
+                delegated(), SLOT(stop()));
 
         mMediaControl = new DelegateMediaControl(delegated(), mToolBarItem);
         mMediaControl->setFlag(QGraphicsItem::ItemIsSelectable, true);
@@ -132,8 +107,16 @@ void UBGraphicsMediaItemDelegate::buildButtons()
         mToolBarItem->setVisibleOnBoard(true);
         mToolBarItem->setShifting(false);
 
-        if (mToolBarShowTimer)
-        {
+        if (!mToolBarShowTimer) {
+
+            if (delegated()->hasLinkedImage()) {
+                mToolBarShowTimer = new QTimer();
+                connect(mToolBarShowTimer, SIGNAL(timeout()), this, SLOT(hideToolBar()));
+                mToolBarShowTimer->setInterval(m_iToolBarShowingInterval);
+            }
+        }
+
+        else {
             connect(mPlayPauseButton, SIGNAL(clicked(bool)),
                     mToolBarShowTimer, SLOT(start()));
 
@@ -195,13 +178,15 @@ void UBGraphicsMediaItemDelegate::positionHandles()
 
 void UBGraphicsMediaItemDelegate::remove(bool canUndo)
 {
-    if (delegated() && delegated()->mediaObject())
-        delegated()->mediaObject()->stop();
+    if (delegated())
+        delegated()->stop();
 
+    /*
     if (delegated()->videoItem()) {
         UBGraphicsScene* scene = dynamic_cast<UBGraphicsScene*>(mDelegated->scene());
         scene->removeItem(delegated()->videoItem());
     }
+    */
 
     UBGraphicsItemDelegate::remove(canUndo);
 }
@@ -223,43 +208,8 @@ UBGraphicsMediaItem* UBGraphicsMediaItemDelegate::delegated()
 
 void UBGraphicsMediaItemDelegate::togglePlayPause()
 {
-    if (delegated() && delegated()->mediaObject()) {
-
-        QMediaPlayer * media = delegated()->mediaObject();
-
-        if (media->state() == QMediaPlayer::StoppedState)
-            media->play();
-
-        else if (media->state() == QMediaPlayer::PlayingState) {
-
-            if ((media->duration() - media->position()) <= 0) {
-                media->stop();
-                media->play();
-            }
-
-            else {
-                media->pause();
-                if(delegated()->scene())
-                        delegated()->scene()->setModified(true);
-            }
-        }
-
-        else if (media->state() == QMediaPlayer::PausedState) {
-            if ((media->duration() - media->position()) <= 0)
-                media->stop();
-
-            media->play();
-        }
-
-        else  if ( media->mediaStatus() == QMediaPlayer::LoadingMedia) {
-            delegated()->mediaObject()->setMedia(delegated()->mediaFileUrl());
-            media->play();
-        }
-
-        if (media->error())
-            qDebug() << "Error appeared." << media->errorString();
-
-    }
+    if (delegated())
+        delegated()->togglePlayPause();
 }
 
 void UBGraphicsMediaItemDelegate::mediaStatusChanged(QMediaPlayer::MediaStatus status)
@@ -268,7 +218,7 @@ void UBGraphicsMediaItemDelegate::mediaStatusChanged(QMediaPlayer::MediaStatus s
     // StalledMedia, BufferingMedia, BufferedMedia, EndOfMedia, InvalidMedia
 
     if (status == QMediaPlayer::LoadedMedia)
-        mMediaControl->totalTimeChanged(delegated()->mediaObject()->duration());
+        mMediaControl->totalTimeChanged(delegated()->mediaDuration());
 
     // in most cases, the only necessary action is to update the play/pause state
     updatePlayPauseState();
@@ -288,15 +238,13 @@ void UBGraphicsMediaItemDelegate::mediaError(QMediaPlayer::Error error)
     // ServiceMissingError
     Q_UNUSED(error);
 
-    qDebug() << "Error appeared." << mMedia->errorString();
+    qDebug() << "Error appeared.";// << mMedia->errorString();
 }
 
 
 void UBGraphicsMediaItemDelegate::updatePlayPauseState()
 {
-    QMediaPlayer * media = delegated()->mediaObject();
-
-    if (media->state() == QMediaPlayer::PlayingState)
+    if (delegated()->playerState() == QMediaPlayer::PlayingState)
         mPlayPauseButton->setFileName(":/images/pause.svg");
     else
         mPlayPauseButton->setFileName(":/images/play.svg");
@@ -305,8 +253,10 @@ void UBGraphicsMediaItemDelegate::updatePlayPauseState()
 
 void UBGraphicsMediaItemDelegate::updateTicker(qint64 time)
 {
-    QMediaPlayer* media = delegated()->mediaObject();
-    mMediaControl->totalTimeChanged(media->duration());
+    // TODO: duration() getter for UBGMediaItem
+    // make sure that all delegate()->mediaObject() calls are removed. 'tis dirty.
+
+    mMediaControl->totalTimeChanged(delegated()->mediaDuration());
     mMediaControl->updateTicker(time);
 }
 
@@ -320,7 +270,7 @@ void UBGraphicsMediaItemDelegate::showHide(bool show)
 {
     QVariant showFlag = QVariant(show ? UBItemLayerType::Object : UBItemLayerType::Control);
     showHideRecurs(showFlag, mDelegated);
-    showHideRecurs(showFlag, delegated()->videoItem());
+    // TODO: call showHideRecurs on the videoItem too (from UBGMI?)
     mDelegated->update();
 
     emit showOnDisplayChanged(show);

src/domain/UBGraphicsMediaItemDelegate.h

@@ -43,7 +43,7 @@ class UBGraphicsMediaItemDelegate :  public UBGraphicsItemDelegate
     Q_OBJECT
 
     public:
-        UBGraphicsMediaItemDelegate(UBGraphicsMediaItem* pDelegated, QMediaPlayer* pMedia, QObject * parent = 0);
+        UBGraphicsMediaItemDelegate(UBGraphicsMediaItem* pDelegated, QObject * parent = 0);
         virtual ~UBGraphicsMediaItemDelegate();
 
         virtual void positionHandles();
@@ -56,6 +56,10 @@ class UBGraphicsMediaItemDelegate :  public UBGraphicsItemDelegate
         void updateTicker(qint64 time);
         virtual void showHide(bool show);
 
+        void mediaStatusChanged(QMediaPlayer::MediaStatus status);
+        void mediaStateChanged(QMediaPlayer::State state);
+        void mediaError(QMediaPlayer::Error error);
+
     protected slots:
 
         virtual void remove(bool canUndo = true);
@@ -68,11 +72,6 @@ class UBGraphicsMediaItemDelegate :  public UBGraphicsItemDelegate
 
         void hideToolBar();
 
-        void mediaStatusChanged(QMediaPlayer::MediaStatus status);
-
-        void mediaStateChanged(QMediaPlayer::State state);
-
-        void mediaError(QMediaPlayer::Error error);
 
     protected:
         virtual void buildButtons();
@@ -84,8 +83,6 @@ class UBGraphicsMediaItemDelegate :  public UBGraphicsItemDelegate
         DelegateButton* mMuteButton;
         DelegateMediaControl* mMediaControl;
 
-        QMediaPlayer* mMedia; // mMedia belongs to the associated UBGraphicsMediaItem (mDelegated)
-
         QTimer* mToolBarShowTimer;
         int m_iToolBarShowingInterval;
 };

src/domain/UBGraphicsScene.cpp

@@ -1349,10 +1349,10 @@ UBGraphicsMediaItem* UBGraphicsScene::addMedia(const QUrl& pMediaFileUrl, bool s
     if (!QFile::exists(pMediaFileUrl.toString()))
         return NULL;
 
-    UBGraphicsMediaItem* mediaItem = new UBGraphicsMediaItem(pMediaFileUrl);
-    if(mediaItem){
+    UBGraphicsMediaItem * mediaItem = UBGraphicsMediaItem::createMediaItem(pMediaFileUrl);
+
+    if(mediaItem)
         connect(UBApplication::boardController, SIGNAL(activeSceneChanged()), mediaItem, SLOT(activeSceneChanged()));
-    }
 
     mediaItem->setPos(pPos);
 
@@ -1361,11 +1361,6 @@ UBGraphicsMediaItem* UBGraphicsScene::addMedia(const QUrl& pMediaFileUrl, bool s
 
     addItem(mediaItem);
 
-    if (mediaItem->videoItem()) {
-        addItem(mediaItem->videoItem());
-        mediaItem->videoItem()->show();
-    }
-
     mediaItem->show();
 
     if (mUndoRedoStackEnabled) { //should be deleted after scene own undo stack implemented
@@ -1373,12 +1368,11 @@ UBGraphicsMediaItem* UBGraphicsScene::addMedia(const QUrl& pMediaFileUrl, bool s
         UBApplication::undoStack->push(uc);
     }
 
-    mediaItem->mediaObject()->play();
+    mediaItem->play();
 
-    if (!shouldPlayAsap)
-    {
-        mediaItem->mediaObject()->pause();
-        mediaItem->mediaObject()->setPosition(0);
+    if (!shouldPlayAsap) {
+        mediaItem->pause();
+        mediaItem->setMediaPos(0);
     }
 
     setDocumentUpdated();

src/domain/UBGraphicsScene.h

@@ -40,8 +40,6 @@ class UBGraphicsProxyWidget;
 class UBGraphicsSvgItem;
 class UBGraphicsPolygonItem;
 class UBGraphicsMediaItem;
-class UBGraphicsVideoItem;
-class UBGraphicsAudioItem;
 class UBGraphicsWidgetItem;
 class UBGraphicsW3CWidgetItem;
 class UBGraphicsAppleWidgetItem;