SANKORE-613

Frame buttons

src/adaptors/UBCFFSubsetAdaptor.cpp

@@ -26,8 +26,7 @@
 #include "domain/UBGraphicsTextItem.h"
 #include "domain/UBGraphicsSvgItem.h"
 #include "domain/UBGraphicsPixmapItem.h"
-#include "domain/UBGraphicsVideoItem.h"
-#include "domain/UBGraphicsAudioItem.h"
+#include "domain/UBGraphicsMediaItem.h"
 #include "domain/UBGraphicsWidgetItem.h"
 #include "domain/UBGraphicsTextItem.h"
 #include "domain/UBGraphicsTextItemDelegate.h"
@@ -823,7 +822,7 @@ bool UBCFFSubsetAdaptor::UBCFFSubsetReader::parseSvgAudio(const QDomElement &ele
         ->addAudioFileToDocument(mCurrentScene->document(), concreteUrl.toLocalFile(), uuid));
 #endif
     
-    UBGraphicsAudioItem *audioItem = mCurrentScene->addAudio(concreteUrl, false);
+    UBGraphicsMediaItem *audioItem = mCurrentScene->addAudio(concreteUrl, false);
     QTransform transform;
     QString textTransform = parentOfAudio.attribute(aTransform);
 
@@ -866,7 +865,7 @@ bool UBCFFSubsetAdaptor::UBCFFSubsetReader::parseSvgVideo(const QDomElement &ele
         ->addVideoFileToDocument(mCurrentScene->document(), concreteUrl.toLocalFile(), uuid));
 #endif
 
-    UBGraphicsVideoItem *videoItem = mCurrentScene->addVideo(concreteUrl, false);
+    UBGraphicsMediaItem *videoItem = mCurrentScene->addVideo(concreteUrl, false);
     QTransform transform;
     QString textTransform = element.attribute(aTransform);
 

src/adaptors/UBSvgSubsetAdaptor.cpp

@@ -22,8 +22,7 @@
 #include "domain/UBGraphicsPixmapItem.h"
 #include "domain/UBGraphicsProxyWidget.h"
 #include "domain/UBGraphicsPolygonItem.h"
-#include "domain/UBGraphicsVideoItem.h"
-#include "domain/UBGraphicsAudioItem.h"
+#include "domain/UBGraphicsMediaItem.h"
 #include "domain/UBGraphicsWidgetItem.h"
 #include "domain/UBGraphicsPDFItem.h"
 #include "domain/UBGraphicsTextItem.h"
@@ -639,7 +638,7 @@ UBGraphicsScene* UBSvgSubsetAdaptor::UBSvgSubsetReader::loadScene()
             }
             else if (mXmlReader.name() == "audio")
             {
-                UBGraphicsAudioItem* audioItem = audioItemFromSvg();
+                UBGraphicsMediaItem* audioItem = audioItemFromSvg();
 
                 if (audioItem)
                 {
@@ -660,7 +659,7 @@ UBGraphicsScene* UBSvgSubsetAdaptor::UBSvgSubsetReader::loadScene()
             }
             else if (mXmlReader.name() == "video")
             {
-                UBGraphicsVideoItem* videoItem = videoItemFromSvg();
+                UBGraphicsMediaItem* videoItem = videoItemFromSvg();
 
                 if (videoItem)
                 {
@@ -1132,17 +1131,14 @@ bool UBSvgSubsetAdaptor::UBSvgSubsetWriter::persistScene(int pageIndex)
                 continue;
             }
 
-            UBGraphicsVideoItem *videoItem = qgraphicsitem_cast<UBGraphicsVideoItem*> (item);
+            UBGraphicsMediaItem *mediaItem = qgraphicsitem_cast<UBGraphicsMediaItem*> (item);
 
-            if (videoItem && videoItem->isVisible())
+            if (mediaItem && mediaItem->isVisible())
             {
-                videoItemToLinkedVideo(videoItem);
-                continue;
-            }
-
-            UBGraphicsAudioItem* audioItem = qgraphicsitem_cast<UBGraphicsAudioItem*> (item);
-            if (audioItem && audioItem->isVisible()) {
-                audioItemToLinkedAudio(audioItem);
+                if (UBGraphicsMediaItem::mediaType_Video == mediaItem->getMediaType())
+                    videoItemToLinkedVideo(mediaItem);
+                else
+                    audioItemToLinkedAudio(mediaItem);
                 continue;
             }
 
@@ -1949,7 +1945,7 @@ UBGraphicsPDFItem* UBSvgSubsetAdaptor::UBSvgSubsetReader::pdfItemFromPDF()
     return pdfItem;
 }
 
-void UBSvgSubsetAdaptor::UBSvgSubsetWriter::audioItemToLinkedAudio(UBGraphicsAudioItem* audioItem)
+void UBSvgSubsetAdaptor::UBSvgSubsetWriter::audioItemToLinkedAudio(UBGraphicsMediaItem* audioItem)
 {
     mXmlWriter.writeStartElement("audio");
 
@@ -1967,7 +1963,7 @@ void UBSvgSubsetAdaptor::UBSvgSubsetWriter::audioItemToLinkedAudio(UBGraphicsAud
 }
 
 
-void UBSvgSubsetAdaptor::UBSvgSubsetWriter::videoItemToLinkedVideo(UBGraphicsVideoItem* videoItem)
+void UBSvgSubsetAdaptor::UBSvgSubsetWriter::videoItemToLinkedVideo(UBGraphicsMediaItem* videoItem)
 {
     /* w3c sample
      *
@@ -1991,7 +1987,7 @@ void UBSvgSubsetAdaptor::UBSvgSubsetWriter::videoItemToLinkedVideo(UBGraphicsVid
     mXmlWriter.writeEndElement();
 }
 
-UBGraphicsAudioItem* UBSvgSubsetAdaptor::UBSvgSubsetReader::audioItemFromSvg()
+UBGraphicsMediaItem* UBSvgSubsetAdaptor::UBSvgSubsetReader::audioItemFromSvg()
 {
 
     QStringRef audioHref = mXmlReader.attributes().value(nsXLink, "href");
@@ -2011,7 +2007,11 @@ UBGraphicsAudioItem* UBSvgSubsetAdaptor::UBSvgSubsetReader::audioItemFromSvg()
         href = mDocumentPath + "/" + href.right(href.length() - indexOfAudioDirectory);
     }
 
-    UBGraphicsAudioItem* audioItem = new UBGraphicsAudioItem(QUrl::fromLocalFile(href));
+    UBGraphicsMediaItem* audioItem = new UBGraphicsMediaItem(QUrl::fromLocalFile(href));
+    if(audioItem){
+        audioItem->connect(UBApplication::boardController, SIGNAL(activeSceneChanged()), audioItem, SLOT(activeSceneChanged()));
+    }
+
     graphicsItemFromSvg(audioItem);
     QStringRef ubPos = mXmlReader.attributes().value(mNamespaceUri, "position");
 
@@ -2025,7 +2025,7 @@ UBGraphicsAudioItem* UBSvgSubsetAdaptor::UBSvgSubsetReader::audioItemFromSvg()
     return audioItem;
 }
 
-UBGraphicsVideoItem* UBSvgSubsetAdaptor::UBSvgSubsetReader::videoItemFromSvg()
+UBGraphicsMediaItem* UBSvgSubsetAdaptor::UBSvgSubsetReader::videoItemFromSvg()
 {
 
     QStringRef videoHref = mXmlReader.attributes().value(nsXLink, "href");
@@ -2045,7 +2045,11 @@ UBGraphicsVideoItem* UBSvgSubsetAdaptor::UBSvgSubsetReader::videoItemFromSvg()
         href = mDocumentPath + "/" + href.right(href.length() - indexOfAudioDirectory);
     }
 
-    UBGraphicsVideoItem* videoItem = new UBGraphicsVideoItem(href);
+    UBGraphicsMediaItem* videoItem = new UBGraphicsMediaItem(QUrl::fromLocalFile(href));
+    if(videoItem){
+        videoItem->connect(UBApplication::boardController, SIGNAL(activeSceneChanged()), videoItem, SLOT(activeSceneChanged()));
+    }
+
     graphicsItemFromSvg(videoItem);
     QStringRef ubPos = mXmlReader.attributes().value(mNamespaceUri, "position");
 

src/adaptors/UBSvgSubsetAdaptor.h

@@ -26,8 +26,7 @@ class UBGraphicsPolygonItem;
 class UBGraphicsPixmapItem;
 class UBGraphicsPDFItem;
 class UBGraphicsWidgetItem;
-class UBGraphicsVideoItem;
-class UBGraphicsAudioItem;
+class UBGraphicsMediaItem;
 class UBGraphicsAppleWidgetItem;
 class UBGraphicsW3CWidgetItem;
 class UBGraphicsTextItem;
@@ -119,9 +118,9 @@ class UBSvgSubsetAdaptor
 
                 UBGraphicsPDFItem* pdfItemFromPDF();
 
-                UBGraphicsVideoItem* videoItemFromSvg();
+                UBGraphicsMediaItem* videoItemFromSvg();
 
-                UBGraphicsAudioItem* audioItemFromSvg();
+                UBGraphicsMediaItem* audioItemFromSvg();
 
                 UBGraphicsAppleWidgetItem* graphicsAppleWidgetFromSvg();
 
@@ -218,8 +217,8 @@ class UBSvgSubsetAdaptor
                 void pixmapItemToLinkedImage(UBGraphicsPixmapItem *pixmapItem);
                 void svgItemToLinkedSvg(UBGraphicsSvgItem *svgItem);
                 void pdfItemToLinkedPDF(UBGraphicsPDFItem *pdfItem);
-                void videoItemToLinkedVideo(UBGraphicsVideoItem *videoItem);
-                void audioItemToLinkedAudio(UBGraphicsAudioItem* audioItem);
+                void videoItemToLinkedVideo(UBGraphicsMediaItem *videoItem);
+                void audioItemToLinkedAudio(UBGraphicsMediaItem *audioItem);
                 void graphicsItemToSvg(QGraphicsItem *item);
                 void graphicsAppleWidgetToSvg(UBGraphicsAppleWidgetItem *item);
                 void graphicsW3CWidgetToSvg(UBGraphicsW3CWidgetItem *item);

src/board/UBBoardController.cpp

@@ -44,8 +44,7 @@
 #include "domain/UBGraphicsProxyWidget.h"
 #include "domain/UBGraphicsSvgItem.h"
 #include "domain/UBGraphicsWidgetItem.h"
-#include "domain/UBGraphicsVideoItem.h"
-#include "domain/UBGraphicsAudioItem.h"
+#include "domain/UBGraphicsMediaItem.h"
 #include "domain/UBGraphicsPDFItem.h"
 #include "domain/UBW3CWidget.h"
 #include "domain/UBGraphicsTextItem.h"
@@ -951,7 +950,7 @@ void UBBoardController::downloadFinished(bool pSuccess, QUrl sourceUrl, QString
     {
         qDebug() << "accepting mime type" << mimeType << "as video";
 
-        UBGraphicsVideoItem *videoItem = 0;
+        UBGraphicsMediaItem *mediaVideoItem = 0;
 
         if (pData.length() > 0)
         {
@@ -960,18 +959,18 @@ void UBBoardController::downloadFinished(bool pSuccess, QUrl sourceUrl, QString
             QUrl url = QUrl::fromLocalFile(UBPersistenceManager::persistenceManager()
                 ->addVideoFileToDocument(mActiveDocument, sourceUrl, pData, uuid));
 
-            videoItem = mActiveScene->addVideo(url, false, pPos);
+            mediaVideoItem = mActiveScene->addMedia(url, false, pPos);
 
-            videoItem->setSourceUrl(sourceUrl);
-            videoItem->setUuid(uuid);
+            mediaVideoItem->setSourceUrl(sourceUrl);
+            mediaVideoItem->setUuid(uuid);
         }
         else
         {
-            videoItem = addVideo(sourceUrl, false, pPos);
+            mediaVideoItem = addVideo(sourceUrl, false, pPos);
         }
 
-        if(videoItem){
-            connect(this, SIGNAL(activeSceneChanged()), videoItem, SLOT(activeSceneChanged()));
+        if(mediaVideoItem){
+            connect(this, SIGNAL(activeSceneChanged()), mediaVideoItem, SLOT(activeSceneChanged()));
         }
 
         UBDrawingController::drawingController()->setStylusTool(UBStylusTool::Selector);
@@ -980,27 +979,27 @@ void UBBoardController::downloadFinished(bool pSuccess, QUrl sourceUrl, QString
     {
         qDebug() << "accepting mime type" << mimeType << "as audio";
 
-        UBGraphicsAudioItem *audioItem = 0;
+        UBGraphicsMediaItem *audioMediaItem = 0;
 
         if (pData.length() > 0)
         {
             QUuid uuid = QUuid::createUuid();
 
             QUrl url = QUrl::fromLocalFile(UBPersistenceManager::persistenceManager()
-                                           ->addAudioFileToDocument(mActiveDocument, sourceUrl, pData, uuid));
+                ->addVideoFileToDocument(mActiveDocument, sourceUrl, pData, uuid));
 
-            audioItem = mActiveScene->addAudio(url, false, pPos);
+            audioMediaItem = mActiveScene->addMedia(url, false, pPos);
 
-            audioItem->setSourceUrl(sourceUrl);
-            audioItem->setUuid(uuid);
+            audioMediaItem->setSourceUrl(sourceUrl);
+            audioMediaItem->setUuid(uuid);
         }
         else
         {
-            audioItem = addAudio(sourceUrl, false, pPos);
+            audioMediaItem = addAudio(sourceUrl, false, pPos);
         }
 
-        if(audioItem){
-            connect(this, SIGNAL(activeSceneChanged()), audioItem, SLOT(activeSceneChanged()));
+        if(audioMediaItem){
+            connect(this, SIGNAL(activeSceneChanged()), audioMediaItem, SLOT(activeSceneChanged()));
         }
 
         UBDrawingController::drawingController()->setStylusTool(UBStylusTool::Selector);
@@ -1805,7 +1804,7 @@ void UBBoardController::controlViewShown()
 }
 
 
-UBGraphicsVideoItem* UBBoardController::addVideo(const QUrl& pSourceUrl, bool startPlay, const QPointF& pos)
+UBGraphicsMediaItem* UBBoardController::addVideo(const QUrl& pSourceUrl, bool startPlay, const QPointF& pos)
 {
     QUuid uuid = QUuid::createUuid();
     QUrl concreteUrl = pSourceUrl;
@@ -1818,7 +1817,7 @@ UBGraphicsVideoItem* UBBoardController::addVideo(const QUrl& pSourceUrl, bool st
                                       ->addVideoFileToDocument(mActiveDocument, pSourceUrl.toLocalFile(), uuid));
 #endif
 
-    UBGraphicsVideoItem* vi = mActiveScene->addVideo(concreteUrl, startPlay, pos);
+    UBGraphicsMediaItem* vi = mActiveScene->addMedia(concreteUrl, startPlay, pos);
     mActiveDocument->setMetaData(UBSettings::documentUpdatedAt, UBStringUtils::toUtcIsoDateTime(QDateTime::currentDateTime()));
 
     if (vi) {
@@ -1830,7 +1829,7 @@ UBGraphicsVideoItem* UBBoardController::addVideo(const QUrl& pSourceUrl, bool st
 
 }
 
-UBGraphicsAudioItem* UBBoardController::addAudio(const QUrl& pSourceUrl, bool startPlay, const QPointF& pos)
+UBGraphicsMediaItem* UBBoardController::addAudio(const QUrl& pSourceUrl, bool startPlay, const QPointF& pos)
 {
     QUuid uuid = QUuid::createUuid();
     QUrl concreteUrl = pSourceUrl;
@@ -1843,15 +1842,15 @@ UBGraphicsAudioItem* UBBoardController::addAudio(const QUrl& pSourceUrl, bool st
                        ->addAudioFileToDocument(mActiveDocument, pSourceUrl.toLocalFile(), uuid));
 #endif
 
-    UBGraphicsAudioItem* vi = mActiveScene->addAudio(concreteUrl, startPlay, pos);
+    UBGraphicsMediaItem* ai = mActiveScene->addMedia(concreteUrl, startPlay, pos);
     mActiveDocument->setMetaData(UBSettings::documentUpdatedAt, UBStringUtils::toUtcIsoDateTime(QDateTime::currentDateTime()));
 
-    if (vi){
-        vi->setUuid(uuid);
-        vi->setSourceUrl(pSourceUrl);
+    if (ai){
+        ai->setUuid(uuid);
+        ai->setSourceUrl(pSourceUrl);
     }
 
-    return vi;
+    return ai;
 
 }
 

src/board/UBBoardController.h

@@ -33,6 +33,7 @@ class UBToolWidget;
 class UBVersion;
 class UBSoftwareUpdate;
 class UBSoftwareUpdateDialog;
+class UBGraphicsMediaItem;
 class UBGraphicsVideoItem;
 class UBGraphicsAudioItem;
 class UBGraphicsWidgetItem;
@@ -204,8 +205,8 @@ class UBBoardController : public QObject
         void grabScene(const QRectF& pSceneRect);
         void controlViewHidden();
         void controlViewShown();
-        UBGraphicsVideoItem* addVideo(const QUrl& pUrl, bool startPlay, const QPointF& pos);
-        UBGraphicsAudioItem* addAudio(const QUrl& pUrl, bool startPlay, const QPointF& pos);
+        UBGraphicsMediaItem* addVideo(const QUrl& pUrl, bool startPlay, const QPointF& pos);
+        UBGraphicsMediaItem* addAudio(const QUrl& pUrl, bool startPlay, const QPointF& pos);
         UBGraphicsWidgetItem *addW3cWidget(const QUrl& pUrl, const QPointF& pos);
 
         void cut();

src/board/UBBoardView.cpp

@@ -47,8 +47,7 @@
 #include "domain/UBGraphicsPDFItem.h"
 #include "domain/UBGraphicsPolygonItem.h"
 #include "domain/UBItem.h"
-#include "domain/UBGraphicsVideoItem.h"
-#include "domain/UBGraphicsAudioItem.h"
+#include "domain/UBGraphicsMediaItem.h"
 #include "domain/UBGraphicsSvgItem.h"
 #include "domain/ubgraphicsgroupcontaineritem.h"
 #include "domain/UBGraphicsStrokesGroup.h"
@@ -560,8 +559,7 @@ UBBoardView::mouseMoveEvent (QMouseEvent *event)
 
               if (item->type() == UBGraphicsW3CWidgetItem::Type
                       || item->type() == UBGraphicsPixmapItem::Type
-                      || item->type() == UBGraphicsVideoItem::Type
-                      || item->type() == UBGraphicsAudioItem::Type
+                      || item->type() == UBGraphicsMediaItem::Type
                       || item->type() == UBGraphicsSvgItem::Type
                       || item->type() == UBGraphicsTextItem::Type
                       || item->type() == UBGraphicsStrokesGroup::Type) {

src/board/UBLibraryController.cpp

@@ -28,7 +28,7 @@
 #include "domain/UBGraphicsScene.h"
 #include "domain/UBGraphicsSvgItem.h"
 #include "domain/UBGraphicsPixmapItem.h"
-#include "domain/UBGraphicsVideoItem.h"
+#include "domain/UBGraphicsMediaItem.h"
 #include "domain/UBGraphicsWidgetItem.h"
 
 #include "tools/UBToolsManager.h"
@@ -698,7 +698,7 @@ void UBLibraryController::addVideosToCurrentPage(const QList<QUrl>& videos)
         mLastItemOffsetIndex++;
         mLastItemOffsetIndex = qMin(mLastItemOffsetIndex, 5);
 
-        UBGraphicsVideoItem* itemInScene = UBApplication::boardController->addVideo(url, false, pos);
+        UBGraphicsMediaItem* itemInScene = UBApplication::boardController->addVideo(url, false, pos);
         itemInScene->setPos(QPoint(pos.x() + 50 * mLastItemOffsetIndex, pos.y() + 50 * mLastItemOffsetIndex));
     }
 }

src/core/UB.h

@@ -111,8 +111,7 @@ struct UBGraphicsItemType
         PolygonItemType = QGraphicsItem::UserType + 1, 
 		PixmapItemType,
         SvgItemType, 
-		VideoItemType, 
-		AudioItemType, 
+		MediaItemType, 
 		AppleWidgetItemType, 
 		PDFItemType, 
 		TextItemType, 

src/domain/UBGraphicsAudioItem.cpp

-/*
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "UBGraphicsAudioItem.h"
-#include "UBGraphicsAudioItemDelegate.h"
-#include "UBGraphicsDelegateFrame.h"
-
-#include "core/memcheck.h"
-
-UBGraphicsAudioItem::UBGraphicsAudioItem(const QUrl& pAudioFileUrl, QGraphicsItem *parent):
-        UBGraphicsMediaItem(pAudioFileUrl,parent)
-{
-    update();
-
-    mAudioOutput = new Phonon::AudioOutput ( Phonon::MusicCategory, this );
-    mMediaObject = new Phonon::MediaObject ( this );
-    mMediaObject->setTickInterval ( 1000 );
-    Phonon::createPath ( mMediaObject, mAudioOutput );
-
-    mMediaObject->clearQueue();
-    mSource = Phonon::MediaSource(pAudioFileUrl);
-    mMediaObject->setCurrentSource (mSource );
-
-    connect (mMediaObject,SIGNAL ( tick ( qint64 ) ), this, SLOT ( tick ( qint64 ) ) );
-    connect(mMediaObject, SIGNAL(stateChanged(Phonon::State,Phonon::State)), this, SLOT(onStateChanged(Phonon::State,Phonon::State)));
-
-    mAudioWidget = new QWidget();
-
-    mSeekSlider = new Phonon::SeekSlider ( mAudioWidget );
-    mSeekSlider->setMediaObject ( mMediaObject );
-
-    QPalette palette;
-    palette.setBrush ( QPalette::Light, Qt::darkGray );
-
-    mTimeLcd = new QLCDNumber;
-    mTimeLcd->setPalette ( palette );
-    mTimeLcd->display ( "00:00" );
-
-    QHBoxLayout *seekerLayout = new QHBoxLayout;
-    seekerLayout->addWidget ( mSeekSlider );
-    seekerLayout->addWidget ( mTimeLcd );
-
-    QVBoxLayout *mainLayout = new QVBoxLayout;
-    mainLayout->addLayout ( seekerLayout );
-
-    mAudioWidget->setLayout ( mainLayout );
-    setWidget ( mAudioWidget );
-
-    UBGraphicsAudioItemDelegate* delegate = new UBGraphicsAudioItemDelegate ( this, mMediaObject );
-    delegate->init();
-    setDelegate ( delegate );
-
-    mDelegate->frame()->setOperationMode ( UBGraphicsDelegateFrame::Resizing );
-
-    setData(UBGraphicsItemData::itemLayerType, QVariant(itemLayerType::ObjectItem)); //Necessary to set if we want z value to be assigned correctly
-
-}
-
-void UBGraphicsAudioItem::onStateChanged(Phonon::State newState, Phonon::State oldState)
-{
-    qDebug() << "STATE CHANGED!";
-    qDebug() << "old state:" << oldState;
-    qDebug() << "new state:" << newState;
-
-    if(oldState == Phonon::ErrorState)
-    {
-        qDebug() << "ERROR! : " << mMediaObject->errorString();
-    }
-    else if(newState == Phonon::LoadingState)
-    {
-        int itotaltime = mMediaObject->totalTime();
-        qDebug() << "[Loading State entered!] Total time : " << itotaltime;
-    }
-}
-
-UBGraphicsAudioItem::~UBGraphicsAudioItem()
-{
-    //NOOP
-}
-
-UBItem* UBGraphicsAudioItem::deepCopy() const
-{
-    QUrl audioUrl = this->mediaFileUrl();
-
-    UBGraphicsAudioItem *copy = new UBGraphicsAudioItem(audioUrl, parentItem());
-
-    connect(UBApplication::boardController, SIGNAL(activeSceneChanged()), copy, SLOT(activeSceneChanged()));
-
-    copy->setPos(this->pos());
-    copy->setTransform(this->transform());
-    copy->setFlag(QGraphicsItem::ItemIsMovable, true);
-    copy->setFlag(QGraphicsItem::ItemIsSelectable, true);
-    copy->setData(UBGraphicsItemData::ItemLayerType, this->data(UBGraphicsItemData::ItemLayerType));
-    copy->setData(UBGraphicsItemData::ItemLocked, this->data(UBGraphicsItemData::ItemLocked));
-    copy->setUuid(this->uuid()); // this is OK as long as Videos are imutable
-    copy->setSourceUrl(this->sourceUrl());
-
-    copy->resize(this->size());
-
-    // TODO UB 4.7 complete all members
-
-    return copy;
-}
-
-void UBGraphicsAudioItem::tick ( qint64 time )
-{
-    QTime displayTime ( 0, ( time / 60000 ) % 60, ( time / 1000 ) % 60 );
-
-    mTimeLcd->display ( displayTime.toString ( "mm:ss" ) );
-}
-
-void UBGraphicsAudioItem::setUuid(const QUuid &pUuid)
-{
-    UBItem::setUuid(pUuid);
-    setData(UBGraphicsItemData::ItemUuid, QVariant(pUuid));
-}

src/domain/UBGraphicsAudioItem.h

-/*
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-#ifndef UBGRAPHICSAUDIOITEM_H
-#define UBGRAPHICSAUDIOITEM_H
-
-#include "UBGraphicsMediaItem.h"
-#include "phonon/seekslider.h"
-#include "phonon/mediasource.h"
-#include "core/UB.h"
-#include "core/UBApplication.h"
-#include "board/UBBoardController.h"
-
-class UBGraphicsAudioItem : public UBGraphicsMediaItem
-{
-    Q_OBJECT
-
-public:
-
-    UBGraphicsAudioItem(const QUrl& pAudioFileUrl, QGraphicsItem *parent = 0);
-    ~UBGraphicsAudioItem();
-
-    enum { Type = UBGraphicsItemType::AudioItemType };
-
-    virtual int type() const
-    {
-        return Type;
-    }
-
-    virtual UBItem* deepCopy () const;
-    virtual UBGraphicsItemDelegate *Delegate() const {return mDelegate;}
-
-    virtual void clearSource()
-    {
-        UBGraphicsMediaItem::clearSource();
-    }
-    void setUuid(const QUuid &pUuid);
-
-private slots:
-
-    void tick ( qint64 time );
-    void onStateChanged(Phonon::State newState,Phonon::State oldState);
-
-protected:
-
-    QWidget* mAudioWidget;
-    QLCDNumber* mTimeLcd;
-
-    Phonon::SeekSlider* mSeekSlider;
-private:
-    Phonon::MediaSource mSource;
-
-};
-
-#endif // UBGRAPHICSAUDIOITEM_H

src/domain/UBGraphicsAudioItemDelegate.cpp

-/*
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "UBGraphicsAudioItemDelegate.h"
-#include "domain/UBGraphicsAudioItem.h"
-#include "domain/UBGraphicsDelegateFrame.h"
-#include "UBGraphicsScene.h"
-
-#include "core/memcheck.h"
-
-UBGraphicsAudioItemDelegate::UBGraphicsAudioItemDelegate ( UBGraphicsAudioItem* pDelegated, QObject *parent )
-        : UBGraphicsItemDelegate ( pDelegated, parent )
-        , mDelegated ( pDelegated )
-{
-    //NOOP
-}
-
-UBGraphicsAudioItemDelegate::~UBGraphicsAudioItemDelegate()
-{
-    //NNOP
-}
-
-
-void UBGraphicsAudioItemDelegate::buildButtons()
-{
-    mPlayPauseButton = new DelegateButton ( ":/images/play.svg", mDelegated, mFrame );
-
-    mStopButton = new DelegateButton ( ":/images/stop.svg", mDelegated, mFrame );
-    mStopButton->hide();
-
-    if ( mDelegated->isMuted() )
-        mMuteButton = new DelegateButton ( ":/images/soundOff.svg", mDelegated, mFrame );
-    else
-        mMuteButton = new DelegateButton ( ":/images/soundOn.svg", mDelegated, mFrame );
-
-    mMuteButton->hide();
-
-
-    connect ( mPlayPauseButton, SIGNAL ( clicked ( bool ) ), this, SLOT ( togglePlayPause() ) );
-    connect ( mStopButton, SIGNAL ( clicked ( bool ) ), mDelegated->mediaObject(), SLOT ( stop() ) );
-    connect ( mMuteButton, SIGNAL ( clicked ( bool ) ), mDelegated, SLOT ( toggleMute() ) );
-    connect ( mMuteButton, SIGNAL ( clicked ( bool ) ), this, SLOT ( toggleMute() ) );
-
-    connect ( mDelegated->mediaObject(), SIGNAL ( stateChanged ( Phonon::State, Phonon::State ) ), this, SLOT ( mediaStateChanged ( Phonon::State, Phonon::State ) ) );
-    connect ( mDelegated->mediaObject(), SIGNAL ( finished() ), this, SLOT ( updatePlayPauseState() ) );
-
-    mButtons << mPlayPauseButton << mStopButton << mMuteButton;
-
-}
-
-void UBGraphicsAudioItemDelegate::togglePlayPause()
-{
-    if ( mDelegated && mDelegated->mediaObject() )
-    {
-        Phonon::MediaObject* media = mDelegated->mediaObject();
-
-        if ( media->state() == Phonon::StoppedState ) {
-            media->play();
-        } else if ( media->state() == Phonon::PlayingState ) {
-            if ( media->remainingTime() <= 0 ) {
-                media->stop();
-                media->play();
-            } else {
-                media->pause();
-                if ( mDelegated->scene() )
-                    mDelegated->scene()->setModified ( true );
-            }
-        } else if ( media->state() == Phonon::PausedState ) {
-            if ( media->remainingTime() <= 0 ) {
-                media->stop();
-            }
-            media->play();
-        } else  if ( media->state() == Phonon::LoadingState ) {
-            mDelegated->mediaObject()->setCurrentSource(mDelegated->mediaFileUrl());
-            media->play();
-        } else if (media->state() == Phonon::ErrorState){
-            qDebug() << "Error appeared." << media->errorString();
-        }
-    }
-}
-
-void UBGraphicsAudioItemDelegate::toggleMute()
-{
-    if ( mDelegated->isMuted() )
-        mMuteButton->setFileName ( ":/images/soundOff.svg" );
-    else
-        mMuteButton->setFileName ( ":/images/soundOn.svg" );
-}
-
-void UBGraphicsAudioItemDelegate::updatePlayPauseState()
-{
-    Phonon::MediaObject* media = mDelegated->mediaObject();
-
-    if ( media->state() == Phonon::PlayingState )
-        mPlayPauseButton->setFileName ( ":/images/pause.svg" );
-    else
-        mPlayPauseButton->setFileName ( ":/images/play.svg" );
-}
-
-void UBGraphicsAudioItemDelegate::mediaStateChanged ( Phonon::State newstate, Phonon::State oldstate )
-{
-    Q_UNUSED ( newstate );
-    Q_UNUSED ( oldstate );
-    updatePlayPauseState();
-}
-
-void UBGraphicsAudioItemDelegate::remove ( bool canUndo )
-{
-    mDelegated->mediaObject()->stop();
-    UBGraphicsItemDelegate::remove ( canUndo );
-}

src/domain/UBGraphicsDelegateFrame.cpp

@@ -585,7 +585,10 @@ void UBGraphicsDelegateFrame::positionHandles()
     
     if (mDelegate->getToolBarItem()->isVisibleOnBoard()
         && mDelegate->getToolBarItem()->isShifting())
-        itemRect.setHeight(itemRect.height() + mDelegate->getToolBarItem()->rect().height() * mDelegate->antiScaleRatio() * 1.1);
+    {
+        QPointF graphicsItemPosition = itemRect.topLeft();
+        itemRect.setTopLeft(graphicsItemPosition-QPointF(0,mDelegate->getToolBarItem()->boundingRect().height()* mDelegate->antiScaleRatio()));
+    }
 
     QTransform itemTransform = delegated()->sceneTransform();
     QPointF topLeft = itemTransform.map(itemRect.topLeft());

src/domain/UBGraphicsItemDelegate.h

@@ -29,6 +29,7 @@ class UBGraphicsScene;
 class UBGraphicsProxyWidget;
 class UBGraphicsDelegateFrame;
 class UBGraphicsWidgetItem;
+class UBGraphicsMediaItem;
 
 class DelegateButton: public QGraphicsSvgItem
 {
@@ -70,6 +71,80 @@ class DelegateButton: public QGraphicsSvgItem
 
 };
 
+class MediaTimer: public QGraphicsRectItem
+{
+public:
+    MediaTimer(QGraphicsItem * parent = 0);
+    ~MediaTimer();
+
+    char* getSegments(char);
+    void addPoint(QPolygon&, const QPoint&);
+    void init();
+    void internalSetString(const QString& s);
+    void drawString(const QString& s, QPainter &, QBitArray * = 0, bool = true);
+    void drawDigit(const QPoint &, QPainter &, int, char, char = ' ');
+    void drawSegment(const QPoint &, char, QPainter &, int, bool = false);
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option,
+                QWidget *widget);
+    void display(const QString &str);
+    void setNumDigits(int nDigits);
+
+private:
+    int ndigits;
+    QString digitStr;
+    QBitArray points;
+    double val;
+
+
+uint fill : 1;
+uint shadow : 1;
+uint smallPoint : 1;
+
+};
+
+class DelegateMediaControl: public QGraphicsRectItem
+{
+    public:
+
+        DelegateMediaControl(UBGraphicsMediaItem* pDelegated, QGraphicsItem * parent = 0);
+
+        virtual ~DelegateMediaControl()
+        {
+            // NOOP
+        }
+
+        void paint(QPainter *painter, const QStyleOptionGraphicsItem *option,
+                QWidget *widget);
+
+        QPainterPath shape() const;
+
+        virtual void mousePressEvent(QGraphicsSceneMouseEvent *event);
+        virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
+        virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
+        virtual void update();
+
+        void positionHandles();
+        void updateTicker(qint64 time);
+        void totalTimeChanged(qint64 newTotalTime);
+
+   protected:
+        void seekToMousePos(QPointF mousePos);
+
+        UBGraphicsMediaItem* mDelegate;
+        bool mDisplayCurrentTime;
+
+        qint64 mCurrentTimeInMs;
+        qint64 mTotalTimeInMs;
+
+    private:
+        int mStartWidth;
+
+        QRectF mSeecArea;
+        QRectF mLCDTimerArea;
+
+        MediaTimer *lcdTimer;
+};
+
 class UBGraphicsToolBarItem : public QGraphicsRectItem, public QObject
 {
     public:
@@ -80,19 +155,21 @@ class UBGraphicsToolBarItem : public QGraphicsRectItem, public QObject
         void setVisibleOnBoard(bool visible) { mVisible = visible; }
         bool isShifting() const { return mShifting; }
         void setShifting(bool shifting) { mShifting = shifting; } 
-        int offsetOnToolBar() const { return mOffsetOnToolBar; }
-        void setOffsetOnToolBar(int pOffset) { mOffsetOnToolBar = pOffset; }
         QList<QGraphicsItem*> itemsOnToolBar() const { return mItemsOnToolBar; }
         void setItemsOnToolBar(QList<QGraphicsItem*> itemsOnToolBar) { mItemsOnToolBar = itemsOnToolBar;}
         int minWidth() { return mMinWidth; }
+        void positionHandles();
+        void update();
+
+    private:
         void paint(QPainter *painter, const QStyleOptionGraphicsItem *option,
                 QWidget *widget);
 
     private:
         bool mShifting;
         bool mVisible;
-        int mOffsetOnToolBar;
         int mMinWidth;
+        int mInitialHeight;
         QList<QGraphicsItem*> mItemsOnToolBar;
 };
 
@@ -168,7 +245,7 @@ class UBGraphicsItemDelegate : public QObject
         void increaseZlevelBottom();
 
     protected:
-        virtual void buildButtons() {;}
+        virtual void buildButtons();
         virtual void decorateMenu(QMenu *menu);
         virtual void updateMenuActionState();
 
@@ -203,9 +280,6 @@ protected slots:
 private:
         void updateFrame();
         void updateButtons(bool showUpdated = false);
-        void updateToolBar();
-
-
 
         QPointF mOffset;
         QTransform mPreviousTransform;

src/domain/UBGraphicsMediaItem.cpp

@@ -13,18 +13,15 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "UBGraphicsGroupContainerItem.h"
 #include "UBGraphicsMediaItem.h"
+#include "UBGraphicsMediaItemDelegate.h"
 #include "UBGraphicsScene.h"
 #include "UBGraphicsDelegateFrame.h"
-
 #include "document/UBDocumentProxy.h"
-
 #include "core/UBApplication.h"
-
 #include "board/UBBoardController.h"
-
 #include "frameworks/UBFileSystemUtils.h"
-
 #include "core/memcheck.h"
 
 bool UBGraphicsMediaItem::sIsMutedByDefault = false;
@@ -35,8 +32,63 @@ UBGraphicsMediaItem::UBGraphicsMediaItem(const QUrl& pMediaFileUrl, QGraphicsIte
         , mMutedByUserAction(sIsMutedByDefault)
         , mMediaFileUrl(pMediaFileUrl)
         , mInitialPos(0)
+        , mVideoWidget(NULL)
+        , mAudioWidget(NULL)
 {
-    //NOOP
+    
+    update();
+
+    QString s = pMediaFileUrl.toLocalFile();
+
+    mMediaObject = new Phonon::MediaObject(this);
+    if (pMediaFileUrl.toLocalFile().contains("videos")) 
+    {
+        mMediaType = mediaType_Video;
+
+        mAudioOutput = new Phonon::AudioOutput(Phonon::VideoCategory, this);
+        mMediaObject->setTickInterval(50);
+        mVideoWidget = new Phonon::VideoWidget(); // owned and destructed by the scene ...
+        Phonon::createPath(mMediaObject, mVideoWidget);
+
+        /*
+         * The VideoVidget should recover the size from the original movie, but this is not always true expecially on
+         * windows and linux os. I don't know why?
+         * In this case the wiget size is equal to QSize(1,1).
+         */
+
+        if(mVideoWidget->sizeHint() == QSize(1,1)){
+            mVideoWidget->resize(320,240);
+        }
+        setWidget(mVideoWidget);
+    }
+    else    
+    if (pMediaFileUrl.toLocalFile().contains("audios"))
+    {
+        mMediaType = mediaType_Audio;
+        mAudioOutput = new Phonon::AudioOutput(Phonon::MusicCategory, this);
+
+        mMediaObject->setTickInterval(1000);
+        mAudioWidget = new QWidget();
+        mAudioWidget->resize(320,26);
+        setWidget(mAudioWidget);
+    }
+
+    Phonon::createPath(mMediaObject, mAudioOutput);
+    
+    mSource = Phonon::MediaSource(pMediaFileUrl);
+    mMediaObject->setCurrentSource(mSource);
+
+    UBGraphicsMediaItemDelegate* itemDelegate = new UBGraphicsMediaItemDelegate(this, mMediaObject);
+    itemDelegate->init();
+    setDelegate(itemDelegate);
+
+    mDelegate->frame()->setOperationMode(UBGraphicsDelegateFrame::Resizing);
+
+    setData(UBGraphicsItemData::itemLayerType, QVariant(itemLayerType::ObjectItem)); //Necessary to set if we want z value to be assigned correctly
+
+    connect(mDelegate, SIGNAL(showOnDisplayChanged(bool)), this, SLOT(showOnDisplayChanged(bool)));
+    connect(mMediaObject, SIGNAL(hasVideoChanged(bool)), this, SLOT(hasMediaChanged(bool)));
+
 }
 
 
@@ -106,8 +158,14 @@ void UBGraphicsMediaItem::toggleMute()
 
 void UBGraphicsMediaItem::hasMediaChanged(bool hasMedia)
 {
+    if(hasMedia && mMediaObject->isSeekable())
+    {
     Q_UNUSED(hasMedia);
     mMediaObject->seek(mInitialPos);
+        UBGraphicsMediaItemDelegate *med = dynamic_cast<UBGraphicsMediaItemDelegate *>(mDelegate);
+        if (med)
+            med->updateTicker(initialPos());
+    }
 }
 
 
@@ -139,3 +197,104 @@ void UBGraphicsMediaItem::showOnDisplayChanged(bool shown)
         mAudioOutput->setMuted(mMuted);
     }
 }
+
+UBItem* UBGraphicsMediaItem::deepCopy() const
+{
+    QUrl url = this->mediaFileUrl();
+    UBGraphicsMediaItem *copy;
+    
+    copy = new UBGraphicsMediaItem(url, parentItem());
+
+    copy->setPos(this->pos());
+    copy->setTransform(this->transform());
+    copy->setFlag(QGraphicsItem::ItemIsMovable, true);
+    copy->setFlag(QGraphicsItem::ItemIsSelectable, true);
+    copy->setData(UBGraphicsItemData::ItemLayerType, this->data(UBGraphicsItemData::ItemLayerType));
+    copy->setData(UBGraphicsItemData::ItemLocked, this->data(UBGraphicsItemData::ItemLocked));
+    copy->setUuid(this->uuid()); // this is OK as long as Videos are imutable
+    copy->setSourceUrl(this->sourceUrl());
+    copy->resize(this->size());
+
+    connect(UBApplication::boardController, SIGNAL(activeSceneChanged()), copy, SLOT(activeSceneChanged()));
+    // TODO UB 4.7 complete all members
+
+    return copy;
+}
+
+void UBGraphicsMediaItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
+{
+//    QDrag* mDrag = new QDrag(event->widget());
+//    QMimeData* pMime = new QMimeData();
+//    mDrag->setMimeData(pMime);
+//    mDrag->start();
+
+//    UBApplication::boardController->activeScene()->setActiveItem(this);
+
+
+    if (mDelegate)
+    {
+        mDelegate->mousePressEvent(event);
+        if (mDelegate && parentItem() && UBGraphicsGroupContainerItem::Type == parentItem()->type())
+        {
+            UBGraphicsGroupContainerItem *group = qgraphicsitem_cast<UBGraphicsGroupContainerItem*>(parentItem());
+            if (group)
+            {
+                QGraphicsItem *curItem = group->getCurrentItem();
+                if (curItem && this != curItem)
+                {   
+                    group->deselectCurrentItem();    
+                }   
+                group->setCurrentItem(this);
+                this->setSelected(true);
+                mDelegate->positionHandles();
+            }       
+
+        }
+        else
+        {
+            mDelegate->getToolBarItem()->show();
+        }
+
+    }
+
+    if (parentItem() && parentItem()->type() == UBGraphicsGroupContainerItem::Type)
+    {
+        mShouldMove = false;
+        if (!Delegate()->mousePressEvent(event))
+        {
+            event->accept();
+        }
+    }
+    else 
+    {
+        mShouldMove = (event->buttons() & Qt::LeftButton);
+        mMousePressPos = event->scenePos();
+        mMouseMovePos = mMousePressPos;
+
+        event->accept();
+        setSelected(true);
+    }
+
+}
+
+void UBGraphicsMediaItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
+{
+    if(mShouldMove && (event->buttons() & Qt::LeftButton))
+    {
+        QPointF offset = event->scenePos() - mMousePressPos;
+
+        if (offset.toPoint().manhattanLength() > QApplication::startDragDistance())
+        {
+            QPointF mouseMovePos = mapFromScene(mMouseMovePos);
+            QPointF eventPos = mapFromScene( event->scenePos());
+
+            QPointF translation = eventPos - mouseMovePos;
+            translate(translation.x(), translation.y());
+        }
+
+        mMouseMovePos = event->scenePos();
+    }
+
+    event->accept();
+
+}

src/domain/UBGraphicsMediaItem.h

@@ -18,6 +18,7 @@
 #include "UBGraphicsProxyWidget.h"
 #include <phonon/AudioOutput>
 #include <phonon/MediaObject>
+#include <phonon/VideoWidget>
 #include "core/UBApplication.h"
 #include "board/UBBoardController.h"
 
@@ -27,10 +28,21 @@ class UBGraphicsMediaItem : public UBGraphicsProxyWidget
     Q_OBJECT
 
 public:
+    typedef enum{
+        mediaType_Video,
+        mediaType_Audio
+    } mediaType;
 
     UBGraphicsMediaItem(const QUrl& pMediaFileUrl, QGraphicsItem *parent = 0);
     ~UBGraphicsMediaItem();
 
+    enum { Type = UBGraphicsItemType::MediaItemType };
+
+    virtual int type() const
+    {
+        return Type;
+    }
+
     void hasMediaChanged(bool hasMedia);
     void showOnDisplayChanged(bool shown);
 
@@ -56,8 +68,17 @@ public:
         return mMuted;
     }
 
+    Phonon::VideoWidget* videoWidget() const
+    {
+        return mVideoWidget;
+    }
+
+    mediaType getMediaType() { return mMediaType; }
+
     virtual UBGraphicsScene* scene();
 
+    virtual UBItem* deepCopy() const;
+
 public slots:
 
     void toggleMute();
@@ -66,11 +87,16 @@ public slots:
 protected:
 
     virtual QVariant itemChange(GraphicsItemChange change, const QVariant &value);
+    virtual void mousePressEvent(QGraphicsSceneMouseEvent *event);
+    virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
 
     virtual void clearSource();
 
     Phonon::MediaObject *mMediaObject;
+    Phonon::VideoWidget *mVideoWidget;
     Phonon::AudioOutput *mAudioOutput;
+    Phonon::MediaSource mSource;
+    QWidget *mAudioWidget;
 
 private:
 
@@ -83,6 +109,20 @@ private:
 
     qint64 mInitialPos;
 
+    mediaType mMediaType;
+
+    bool mShouldMove;
+    QPointF mMousePressPos;
+    QPointF mMouseMovePos;
+
+};
+
+
+class UBGraphicsUnitedMediaItem : public UBGraphicsMediaItem 
+{
+public:
+    UBGraphicsUnitedMediaItem(const QUrl& pMediaFileUrl, QGraphicsItem *parent = 0);
+
 };
 
 #endif // UBGRAPHICSMEDIAITEM_H

src/domain/UBGraphicsScene.cpp

@@ -50,8 +50,7 @@
 #include "UBGraphicsPixmapItem.h"
 #include "UBGraphicsSvgItem.h"
 #include "UBGraphicsPolygonItem.h"
-#include "UBGraphicsVideoItem.h"
-#include "UBGraphicsAudioItem.h"
+#include "UBGraphicsMediaItem.h"
 #include "UBGraphicsWidgetItem.h"
 #include "UBGraphicsPDFItem.h"
 #include "UBGraphicsTextItem.h"
@@ -1331,67 +1330,48 @@ void UBGraphicsScene::textUndoCommandAdded(UBGraphicsTextItem *textItem)
         UBApplication::undoStack->push(uc);
     }
 }
-
-UBGraphicsVideoItem* UBGraphicsScene::addVideo(const QUrl& pVideoFileUrl, bool shouldPlayAsap, const QPointF& pPos)
+UBGraphicsMediaItem* UBGraphicsScene::addMedia(const QUrl& pMediaFileUrl, bool shouldPlayAsap, const QPointF& pPos)
 {
-    UBGraphicsVideoItem* videoItem = new UBGraphicsVideoItem(pVideoFileUrl);
+    UBGraphicsMediaItem* mediaItem = new UBGraphicsMediaItem(pMediaFileUrl);
+    if(mediaItem){
+        connect(UBApplication::boardController, SIGNAL(activeSceneChanged()), mediaItem, SLOT(activeSceneChanged()));
+    }
 
-    videoItem->setPos(pPos);
+    mediaItem->setPos(pPos);
 
-    videoItem->setFlag(QGraphicsItem::ItemIsMovable, true);
-    videoItem->setFlag(QGraphicsItem::ItemIsSelectable, true);
+    mediaItem->setFlag(QGraphicsItem::ItemIsMovable, true);
+    mediaItem->setFlag(QGraphicsItem::ItemIsSelectable, true);
 
-    addItem(videoItem);
+    addItem(mediaItem);
 
-    videoItem->show();
+    mediaItem->show();
 
     if (enableUndoRedoStack) { //should be deleted after scene own undo stack implemented
-        UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, 0, videoItem);
+        UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, 0, mediaItem);
         UBApplication::undoStack->push(uc);
     }
 
-    videoItem->mediaObject()->play();
+    mediaItem->mediaObject()->play();
 
     if (!shouldPlayAsap)
     {
-        videoItem->mediaObject()->pause();
-        videoItem->mediaObject()->seek(0);
+        mediaItem->mediaObject()->pause();
+        mediaItem->mediaObject()->seek(0);
     }
 
     setDocumentUpdated();
 
-    return videoItem;
+    return mediaItem;
 }
 
-UBGraphicsAudioItem* UBGraphicsScene::addAudio(const QUrl& pAudioFileUrl, bool shouldPlayAsap, const QPointF& pPos)
+UBGraphicsMediaItem* UBGraphicsScene::addVideo(const QUrl& pVideoFileUrl, bool shouldPlayAsap, const QPointF& pPos)
 {
-    UBGraphicsAudioItem* audioItem = new UBGraphicsAudioItem(pAudioFileUrl);
-
-    audioItem->setPos(pPos);
-
-    audioItem->setFlag(QGraphicsItem::ItemIsMovable, true);
-    audioItem->setFlag(QGraphicsItem::ItemIsSelectable, true);
-
-    addItem(audioItem);
-
-    audioItem->show();
-
-    if (enableUndoRedoStack) { //should be deleted after scene own undo stack implemented
-        UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, 0, audioItem);
-        UBApplication::undoStack->push(uc);
-    }
-
-    audioItem->mediaObject()->play();
-
-    if (!shouldPlayAsap)
-    {
-        audioItem->mediaObject()->pause();
-        audioItem->mediaObject()->seek(0);
-    }
-
-    setDocumentUpdated();
+   return addMedia(pVideoFileUrl, shouldPlayAsap, pPos);
+}
 
-    return audioItem;
+UBGraphicsMediaItem* UBGraphicsScene::addAudio(const QUrl& pAudioFileUrl, bool shouldPlayAsap, const QPointF& pPos)
+{
+   return addMedia(pAudioFileUrl, shouldPlayAsap, pPos);
 }
 
 UBGraphicsWidgetItem* UBGraphicsScene::addWidget(const QUrl& pWidgetUrl, const QPointF& pPos)
@@ -2067,7 +2047,7 @@ QList<QUrl> UBGraphicsScene::relativeDependencies() const
 
     while (itItems.hasNext())
     {
-        UBGraphicsVideoItem *videoItem = qgraphicsitem_cast<UBGraphicsVideoItem*> (itItems.next());
+        UBGraphicsMediaItem *videoItem = qgraphicsitem_cast<UBGraphicsMediaItem*> (itItems.next());
 
         if (videoItem && videoItem->mediaFileUrl().isRelative())
         {

src/domain/UBGraphicsScene.h

@@ -29,6 +29,7 @@ class UBGraphicsPixmapItem;
 class UBGraphicsProxyWidget;
 class UBGraphicsSvgItem;
 class UBGraphicsPolygonItem;
+class UBGraphicsMediaItem;
 class UBGraphicsVideoItem;
 class UBGraphicsAudioItem;
 class UBGraphicsWidgetItem;
@@ -130,8 +131,9 @@ class UBGraphicsScene: public UBCoreGraphicsScene, public UBItem
         UBGraphicsW3CWidgetItem* addW3CWidget(const QUrl& pWidgetUrl, const QPointF& pPos = QPointF(0, 0),int widgetType = UBGraphicsItemType::W3CWidgetItemType);
         void addGraphicsWidget(UBGraphicsWidgetItem* graphicsWidget, const QPointF& pPos = QPointF(0, 0));
 
-        UBGraphicsVideoItem* addVideo(const QUrl& pVideoFileUrl, bool shouldPlayAsap, const QPointF& pPos = QPointF(0, 0));
-        UBGraphicsAudioItem* addAudio(const QUrl& pAudioFileUrl, bool shouldPlayAsap, const QPointF& pPos = QPointF(0, 0));
+        UBGraphicsMediaItem* addMedia(const QUrl& pMediaFileUrl, bool shouldPlayAsap, const QPointF& pPos = QPointF(0, 0));
+        UBGraphicsMediaItem* addVideo(const QUrl& pVideoFileUrl, bool shouldPlayAsap, const QPointF& pPos = QPointF(0, 0));
+        UBGraphicsMediaItem* addAudio(const QUrl& pAudioFileUrl, bool shouldPlayAsap, const QPointF& pPos = QPointF(0, 0));
         UBGraphicsSvgItem* addSvg(const QUrl& pSvgFileUrl, const QPointF& pPos = QPointF(0, 0));
         UBGraphicsTextItem* addText(const QString& pString, const QPointF& pTopLeft = QPointF(0, 0));
         UBGraphicsTextItem* textForObjectName(const QString& pString, const QString &objectName = "UBTGZeroPageSessionTitle");

src/domain/UBGraphicsTextItem.cpp

@@ -14,6 +14,7 @@
  */
 
 #include <QtGui>
+#include "UBGraphicsGroupContainerItem.h"
 #include "UBGraphicsTextItem.h"
 #include "UBGraphicsTextItemDelegate.h"
 #include "UBGraphicsScene.h"
@@ -97,8 +98,32 @@ QVariant UBGraphicsTextItem::itemChange(GraphicsItemChange change, const QVarian
 
 void UBGraphicsTextItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
 {
+    
     if (mDelegate)
+    {
         mDelegate->mousePressEvent(event);
+        if (mDelegate && parentItem() && UBGraphicsGroupContainerItem::Type == parentItem()->type())
+        {
+            UBGraphicsGroupContainerItem *group = qgraphicsitem_cast<UBGraphicsGroupContainerItem*>(parentItem());
+            if (group)
+            {
+                QGraphicsItem *curItem = group->getCurrentItem();
+                if (curItem && this != curItem)
+                {   
+                    group->deselectCurrentItem();    
+                }   
+                group->setCurrentItem(this);
+                this->setSelected(true);
+                mDelegate->positionHandles();
+            }       
+
+        }
+        else
+        {
+            mDelegate->getToolBarItem()->show();
+        }
+
+    }
 
     if (!data(UBGraphicsItemData::ItemEditable).toBool())
         return;

src/domain/UBGraphicsTextItemDelegate.cpp

@@ -16,6 +16,8 @@
 #include <QtGui>
 #include <QtSvg>
 
+#include "core/UBApplication.h"
+#include "UBGraphicsGroupContainerItem.h"
 #include "UBGraphicsTextItemDelegate.h"
 #include "UBGraphicsScene.h"
 #include "gui/UBResources.h"
@@ -108,7 +110,7 @@ void UBGraphicsTextItemDelegate::buildButtons()
     QList<QGraphicsItem*> itemsOnToolBar;
     itemsOnToolBar << mFontButton << mColorButton << mDecreaseSizeButton << mIncreaseSizeButton;
     mToolBarItem->setItemsOnToolBar(itemsOnToolBar);
-
+    mToolBarItem->setShifting(true);
     mToolBarItem->setVisibleOnBoard(true);
 }
 
@@ -281,6 +283,39 @@ void UBGraphicsTextItemDelegate::updateMenuActionState()
 void UBGraphicsTextItemDelegate::positionHandles()
 {
     UBGraphicsItemDelegate::positionHandles();
+
+    if (mDelegated->isSelected() || (mDelegated->parentItem() && UBGraphicsGroupContainerItem::Type == mDelegated->parentItem()->type())) 
+    {
+        if (mToolBarItem->isVisibleOnBoard())
+        {
+            qreal AntiScaleRatio = 1 / (UBApplication::boardController->systemScaleFactor() * UBApplication::boardController->currentZoom());    
+            mToolBarItem->setScale(AntiScaleRatio);
+            QRectF toolBarRect = mToolBarItem->rect();
+            toolBarRect.setWidth(delegated()->boundingRect().width()/AntiScaleRatio);
+            mToolBarItem->setRect(toolBarRect);           
+            mToolBarItem->positionHandles();
+            mToolBarItem->update();
+            if (mToolBarItem->isShifting())
+                mToolBarItem->setPos(0,-mToolBarItem->boundingRect().height()*AntiScaleRatio);
+            else
+                mToolBarItem->setPos(0, 0);
+
+            UBGraphicsGroupContainerItem *group = qgraphicsitem_cast<UBGraphicsGroupContainerItem*>(mDelegated->parentItem());
+
+            mToolBarItem->hide();
+            if (group && group->getCurrentItem() == mDelegated && group->isSelected())
+                mToolBarItem->show();
+
+            if (!group)
+                 mToolBarItem->show();
+
+        }
+    }
+    else
+    {
+        mToolBarItem->hide();
+    }
+
     setEditable(isEditable());
 }
 

src/domain/UBGraphicsVideoItem.cpp

-/*
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "UBGraphicsVideoItem.h"
-#include "UBGraphicsVideoItemDelegate.h"
-#include "UBGraphicsDelegateFrame.h"
-
-#include "core/memcheck.h"
-
-UBGraphicsVideoItem::UBGraphicsVideoItem(const QUrl& pVideoFileUrl, QGraphicsItem *parent):
-        UBGraphicsMediaItem(pVideoFileUrl,parent)
-        , mShouldMove(false)
-{
-    update();
-
-    mMediaObject = new Phonon::MediaObject(this);
-    mVideoWidget = new Phonon::VideoWidget(); // owned and destructed by the scene ...
-
-    Phonon::createPath(mMediaObject, mVideoWidget);
-
-    mAudioOutput = new Phonon::AudioOutput(Phonon::VideoCategory, this);
-    Phonon::createPath(mMediaObject, mAudioOutput);
-
-    /*
-     * The VideoVidget should recover the size from the original movie, but this is not always true expecially on
-     * windows and linux os. I don't know why?
-     * In this case the wiget size is equal to QSize(1,1).
-     */
-
-    if(mVideoWidget->sizeHint() == QSize(1,1)){
-      mVideoWidget->resize(320,240);
-    }
-
-    setWidget(mVideoWidget);
-
-    UBGraphicsVideoItemDelegate* delegate = new UBGraphicsVideoItemDelegate(this, mMediaObject);
-    delegate->init();
-    setDelegate(delegate);
-
-    mDelegate->frame()->setOperationMode(UBGraphicsDelegateFrame::Resizing);
-
-    setData(UBGraphicsItemData::itemLayerType, QVariant(itemLayerType::ObjectItem)); //Necessary to set if we want z value to be assigned correctly
-
-    connect(mDelegate, SIGNAL(showOnDisplayChanged(bool)), this, SLOT(showOnDisplayChanged(bool)));
-    connect(mMediaObject, SIGNAL(hasVideoChanged(bool)), this, SLOT(hasVideoChanged(bool)));
-}
-
-
-UBGraphicsVideoItem::~UBGraphicsVideoItem()
-{
-    //NOOP
-}
-
-UBItem* UBGraphicsVideoItem::deepCopy() const
-{
-    QUrl videoUrl = this->mediaFileUrl();
-
-    UBGraphicsVideoItem *copy = new UBGraphicsVideoItem(videoUrl, parentItem());
-
-    connect(UBApplication::boardController, SIGNAL(activeSceneChanged()), copy, SLOT(activeSceneChanged()));
-
-    copy->setPos(this->pos());
-    copy->setTransform(this->transform());
-    copy->setFlag(QGraphicsItem::ItemIsMovable, true);
-    copy->setFlag(QGraphicsItem::ItemIsSelectable, true);
-    copy->setData(UBGraphicsItemData::ItemLayerType, this->data(UBGraphicsItemData::ItemLayerType));
-    copy->setData(UBGraphicsItemData::ItemLocked, this->data(UBGraphicsItemData::ItemLocked));
-    copy->setUuid(this->uuid()); // this is OK as long as Videos are imutable
-    copy->setSourceUrl(this->sourceUrl());
-
-    copy->resize(this->size());
-
-    // TODO UB 4.7 complete all members
-
-    return copy;
-}
-
-
-
-void UBGraphicsVideoItem::hasVideoChanged(bool hasVideo)
-{
-    if(hasVideo && mMediaObject->isSeekable())
-    {
-        hasMediaChanged(hasVideo);
-        UBGraphicsVideoItemDelegate *vid = dynamic_cast<UBGraphicsVideoItemDelegate *>(mDelegate);
-        if (vid)
-            vid->updateTicker(initialPos());
-    }
-}
-
-void UBGraphicsVideoItem::showOnDisplayChanged(bool shown)
-{
-    UBGraphicsMediaItem::showOnDisplayChanged(shown);
-    UBGraphicsVideoItemDelegate *vid = dynamic_cast<UBGraphicsVideoItemDelegate*>(mDelegate);
-
-    if (vid)
-        vid->toggleMute();
-}
-
-void UBGraphicsVideoItem::setUuid(const QUuid &pUuid)
-{
-    UBItem::setUuid(pUuid);
-    setData(UBGraphicsItemData::ItemUuid, QVariant(pUuid)); //store item uuid inside the QGraphicsItem to fast operations with Items on the scene
-}
-
-void UBGraphicsVideoItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
-{
-    mShouldMove = (event->buttons() & Qt::LeftButton);
-    mMousePressPos = event->scenePos();
-    mMouseMovePos = mMousePressPos;
-
-    event->accept();
-    setSelected(true);
-
-}
-
-void UBGraphicsVideoItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
-{
-    if(mShouldMove && (event->buttons() & Qt::LeftButton))
-    {
-        QPointF offset = event->scenePos() - mMousePressPos;
-
-        if (offset.toPoint().manhattanLength() > QApplication::startDragDistance())
-        {
-            QPointF mouseMovePos = mapFromScene(mMouseMovePos);
-            QPointF eventPos = mapFromScene( event->scenePos());
-
-            QPointF translation = eventPos - mouseMovePos;
-            translate(translation.x(), translation.y());
-        }
-
-        mMouseMovePos = event->scenePos();
-    }
-
-    event->accept();
-
-}

src/domain/UBGraphicsVideoItem.h

-/*
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-#ifndef UBGRAPHICSVIDEOITEM_H
-#define UBGRAPHICSVIDEOITEM_H
-
-#include <phonon/VideoWidget>
-#include "UBGraphicsMediaItem.h"
-#include "core/UB.h"
-#include "core/UBApplication.h"
-#include "board/UBBoardController.h"
-
-class UBGraphicsVideoItem : public UBGraphicsMediaItem
-{
-    Q_OBJECT;
-
-public:
-    UBGraphicsVideoItem(const QUrl& pMediaFileUrl, QGraphicsItem *parent = 0);
-    ~UBGraphicsVideoItem();
-
-    enum { Type = UBGraphicsItemType::VideoItemType };
-
-    virtual int type() const
-    {
-        return Type;
-    }
-
-    virtual UBItem* deepCopy() const;
-
-    Phonon::VideoWidget* videoWidget() const
-    {
-        return mVideoWidget;
-    }
-    virtual UBGraphicsItemDelegate *Delegate() const {return mDelegate;}
-
-    virtual void clearSource()
-    {
-        UBGraphicsMediaItem::clearSource();
-    }
-    virtual void setUuid(const QUuid &pUuid);
-
-public slots:
-    void hasVideoChanged(bool hasVideo);
-
-
-protected:
-
-    virtual void mousePressEvent(QGraphicsSceneMouseEvent *event);
-    virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
-
-    Phonon::VideoWidget *mVideoWidget;
-
-private slots:
-    void showOnDisplayChanged(bool shown);
-
-
-private:
-    bool mShouldMove;
-    QPointF mMousePressPos;
-    QPointF mMouseMovePos;
-
-
-};
-
-#endif // UBGRAPHICSVIDEOITEM_H

src/domain/domain.pri

@@ -10,7 +10,6 @@ HEADERS      += src/domain/UBGraphicsScene.h \
                 src/domain/UBGraphicsSvgItem.h \
                 src/domain/UBGraphicsPolygonItem.h \
                 src/domain/UBItem.h \
-                src/domain/UBGraphicsVideoItem.h \
                 src/domain/UBGraphicsWidgetItem.h \
                 src/domain/UBAppleWidget.h \
                 src/domain/UBGraphicsPDFItem.h \
@@ -20,8 +19,6 @@ HEADERS      += src/domain/UBGraphicsScene.h \
                 src/domain/UBResizableGraphicsItem.h \
                 src/domain/UBGraphicsStroke.h \
     src/domain/UBGraphicsMediaItem.h \
-    src/domain/UBGraphicsAudioItem.h \
-    src/domain/UBGraphicsAudioItemDelegate.h \
     src/domain/UBAbstractUndoCommand.h\
     src/domain/UBAngleWidget.h \
     src/domain/ubgraphicsgroupcontaineritem.h \
@@ -29,10 +26,10 @@ HEADERS      += src/domain/UBGraphicsScene.h \
     src/domain/UBGraphicsStrokesGroup.h
                 
 HEADERS      += src/domain/UBGraphicsItemDelegate.h \
-				src/domain/UBGraphicsVideoItemDelegate.h \
 				src/domain/UBGraphicsTextItemDelegate.h \
                 src/domain/UBGraphicsDelegateFrame.h \
-                src/domain/UBGraphicsWidgetItemDelegate.h
+                src/domain/UBGraphicsWidgetItemDelegate.h \
+                src/domain/UBGraphicsMediaItemDelegate.h
                 
                 
 SOURCES      += src/domain/UBGraphicsScene.cpp \
@@ -56,8 +53,6 @@ SOURCES      += src/domain/UBGraphicsScene.cpp \
                 src/domain/UBResizableGraphicsItem.cpp \
                 src/domain/UBGraphicsStroke.cpp \
     src/domain/UBGraphicsMediaItem.cpp \
-    src/domain/UBGraphicsAudioItem.cpp \
-    src/domain/UBGraphicsAudioItemDelegate.cpp \
     src/domain/UBAbstractUndoCommand.cpp \
     src/domain/UBAngleWidget.cpp \
     src/domain/ubgraphicsgroupcontaineritem.cpp \
@@ -65,8 +60,8 @@ SOURCES      += src/domain/UBGraphicsScene.cpp \
     src/domain/UBGraphicsStrokesGroup.cpp
                 
 SOURCES      += src/domain/UBGraphicsItemDelegate.cpp \
-				src/domain/UBGraphicsVideoItemDelegate.cpp \
 			src/domain/UBGraphicsTextItemDelegate.cpp \
+                src/domain/UBGraphicsMediaItemDelegate.cpp \
                 src/domain/UBGraphicsDelegateFrame.cpp \
-                src/domain/UBGraphicsWidgetItemDelegate.cpp
+                src/domain/UBGraphicsWidgetItemDelegate.cpp \
                 

src/domain/ubgraphicsgroupcontaineritem.cpp

@@ -2,6 +2,8 @@
 
 #include <QtGui>
 
+#include "UBGraphicsMediaItem.h"
+#include "UBGraphicsTextItem.h"
 #include "domain/UBGraphicsItemDelegate.h"
 #include "domain/ubgraphicsgroupcontaineritemdelegate.h"
 #include "domain/UBGraphicsScene.h"
@@ -10,6 +12,7 @@
 
 UBGraphicsGroupContainerItem::UBGraphicsGroupContainerItem(QGraphicsItem *parent)
     : QGraphicsItem(parent)
+    , mCurrentItem(NULL)
 {
     setData(UBGraphicsItemData::ItemLayerType, UBItemLayerType::Object);
 
@@ -128,6 +131,29 @@ void UBGraphicsGroupContainerItem::removeFromGroup(QGraphicsItem *item)
     itemsBoundingRect = childrenBoundingRect();
 }
 
+void UBGraphicsGroupContainerItem::deselectCurrentItem()
+{
+    if (mCurrentItem)
+    {
+        switch(mCurrentItem->type())
+        {
+        case UBGraphicsTextItem::Type:
+              {
+                  dynamic_cast<UBGraphicsTextItem*>(mCurrentItem)->Delegate()->getToolBarItem()->hide();
+              }
+              break;
+        case UBGraphicsMediaItem::Type:
+              {
+                  dynamic_cast<UBGraphicsMediaItem*>(mCurrentItem)->Delegate()->getToolBarItem()->hide();
+              }
+              break;                   
+
+        }
+        mCurrentItem->setSelected(false);
+        mCurrentItem = NULL;
+    }
+}
+
 QRectF UBGraphicsGroupContainerItem::boundingRect() const
 {
     return itemsBoundingRect;
@@ -234,5 +260,20 @@ void UBGraphicsGroupContainerItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *e
 QVariant UBGraphicsGroupContainerItem::itemChange(GraphicsItemChange change, const QVariant &value)
 {
     QVariant newValue = mDelegate->itemChange(change, value);
+
+    foreach(QGraphicsItem *child, children())
+    {
+        UBGraphicsItem *item = dynamic_cast<UBGraphicsItem*>(child);
+        if (item)
+        {
+            item->Delegate()->positionHandles();
+        }
+    }
+
+    if (QGraphicsItem::ItemSelectedChange == change)
+    {
+        deselectCurrentItem();
+    }
+
     return QGraphicsItem::itemChange(change, newValue);
 }

src/domain/ubgraphicsgroupcontaineritem.h

@@ -13,6 +13,10 @@ public:
 
     void addToGroup(QGraphicsItem *item);
     void removeFromGroup(QGraphicsItem *item);
+    void setCurrentItem(QGraphicsItem *item){mCurrentItem = item;}
+    QGraphicsItem *getCurrentItem() const {return mCurrentItem;}
+    void deselectCurrentItem();
+
     QRectF boundingRect() const;
     void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
 
@@ -41,6 +45,7 @@ protected:
 
 private:
     QRectF itemsBoundingRect;
+    QGraphicsItem *mCurrentItem;
 
 };
 

src/domain/ubgraphicsgroupcontaineritemdelegate.cpp

@@ -50,7 +50,7 @@ void UBGraphicsGroupContainerItemDelegate::buildButtons()
 bool UBGraphicsGroupContainerItemDelegate::mousePressEvent(QGraphicsSceneMouseEvent *event)
 {
     Q_UNUSED(event)
-
+    delegated()->deselectCurrentItem();
     return false;
 }
 

src/frameworks/UBCoreGraphicsScene.cpp

@@ -15,8 +15,6 @@
 
 #include "UBCoreGraphicsScene.h"
 
-#include "domain/UBGraphicsAudioItem.h"
-#include "domain/UBGraphicsVideoItem.h"
 #include "domain/UBGraphicsMediaItem.h"
 #include "domain/UBGraphicsWidgetItem.h"
 
@@ -66,11 +64,8 @@ bool UBCoreGraphicsScene::deleteItem(QGraphicsItem* item)
         UBGraphicsItem* item_casted = 0;
         switch (item->type())
         {
-        case UBGraphicsAudioItem::Type:
-                item_casted = dynamic_cast<UBGraphicsAudioItem*>(item);
-                break;
-        case UBGraphicsVideoItem::Type:
-                item_casted = dynamic_cast<UBGraphicsVideoItem*>(item);
+        case UBGraphicsMediaItem::Type:
+                item_casted = dynamic_cast<UBGraphicsMediaItem*>(item);
                 break;
         case UBGraphicsW3CWidgetItem::Type:
                 item_casted = dynamic_cast<UBGraphicsWidgetItem*>(item);